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

xulbux/xx_console.py

@@ -11,7 +11,7 @@ from .xx_string import String
 from .xx_color import Color, rgba, hexa
 
 from prompt_toolkit.key_binding.key_bindings import KeyBindings
-from typing import Optional
+from typing import Optional, Any
 import prompt_toolkit as _prompt_toolkit
 import pyperclip as _pyperclip
 import keyboard as _keyboard
@@ -22,64 +22,83 @@ import sys as _sys
 import os as _os
 
 
-# YAPF: disable
 class _ConsoleWidth:
+
     def __get__(self, obj, owner=None):
         return _os.get_terminal_size().columns
 
+
 class _ConsoleHeight:
+
     def __get__(self, obj, owner=None):
         return _os.get_terminal_size().lines
 
+
 class _ConsoleSize:
+
     def __get__(self, obj, owner=None):
         size = _os.get_terminal_size()
         return (size.columns, size.lines)
 
+
 class _ConsoleUser:
+
     def __get__(self, obj, owner=None):
         return _os.getenv("USER") or _os.getenv("USERNAME") or _getpass.getuser()
 
+
 class ArgResult:
     """Exists: if the argument was found or not\n
     Value: the value from behind the found argument"""
-    def __init__(self, exists: bool, value: any):
+
+    def __init__(self, exists: bool, value: Any):
         self.exists = exists
         self.value = value
+
     def __bool__(self):
         return self.exists
 
+
 class Args:
     """Stores found command arguments under their aliases with their results."""
+
     def __init__(self, **kwargs):
         for key, value in kwargs.items():
             if not key.isidentifier():
                 raise TypeError(f"Argument alias '{key}' is invalid. It must be a valid Python variable name.")
             setattr(self, key, ArgResult(**value))
+
     def __len__(self):
         return len(vars(self))
+
     def __contains__(self, key):
         return hasattr(self, key)
+
     def __getitem__(self, key):
         if isinstance(key, int):
             return list(self.__iter__())[key]
         return getattr(self, key)
+
     def __iter__(self):
         for key, value in vars(self).items():
             yield (key, {"exists": value.exists, "value": value.value})
-    def dict(self) -> dict[str, dict[str, any]]:
+
+    def dict(self) -> dict[str, dict[str, Any]]:
         """Returns the arguments as a dictionary."""
         return {k: {"exists": v.exists, "value": v.value} for k, v in vars(self).items()}
+
     def keys(self):
         """Returns the argument aliases as `dict_keys([...])`."""
         return vars(self).keys()
+
     def values(self):
         """Returns the argument results as `dict_values([...])`."""
         return vars(self).values()
+
     def items(self):
-        """Returns the argument aliases and results as `dict_items([...])`."""
-        return vars(self).items()
-# YAPF: enable
+        """Yields tuples of `(alias, {'exists': bool, 'value': Any})`."""
+        for key, value in self.__iter__():
+            yield (key, value)
 
 
 class Console:
@@ -95,33 +114,50 @@ class Console:
     """The name of the current user."""
 
     @staticmethod
-    def get_args(find_args: dict[str, list[str] | tuple[str, ...]], allow_spaces: bool = False) -> Args:
+    def get_args(
+        find_args: dict[str, list[str] | tuple[str, ...] | dict[str, list[str] | tuple[str, ...] | Any]],
+        allow_spaces: bool = False
+    ) -> Args:
         """Will search for the specified arguments in the command line
         arguments and return the results as a special `Args` object.\n
         ----------------------------------------------------------------
-        The `find_args` dictionary should have the following structure:
+        The `find_args` dictionary can have the following structures for each alias:
+        1. Simple list/tuple of flags (when no default value is needed):
+           ```python
+           "alias_name": ["-f", "--flag"]
+           ```
+        2. Dictionary with 'flags' and optional 'default':
+           ```python
+           "alias_name": {
+               "flags": ["-f", "--flag"],
+               "default": "some_value"  # Optional
+           }
+           ```
+        Example `find_args`:
         ```python
         find_args={
-            "arg1_alias": ["-a1", "--arg1", "--argument-1"],
-            "arg2_alias": ("-a2", "--arg2", "--argument-2"),
-            ...
+            "arg1": { # With default
+                "flags": ["-a1", "--arg1"],
+                "default": "default_val"
+            },
+            "arg2": ("-a2", "--arg2"), # Without default (original format)
+            "arg3": ["-a3"],          # Without default (list format)
+            "arg4": { # Flag with default True
+                "flags": ["-f"],
+                "default": True
+            }
         }
         ```
-        And if the script is called via the command line:\n
-        `python script.py -a1 "argument value" --arg2`\n
-        ...it would return the following `Args` object:
-        ```python
-        Args(
-            arg1_alias=ArgResult(exists=True, value="argument value"),
-            arg2_alias=ArgResult(exists=True, value=None),
-            ...
-        )
-        ```
-        ...which can be accessed like this:\n
-        - `Args.<arg_alias>.exists` is `True` if any of the specified
-            args were found and `False` if not
-        - `Args.<arg_alias>.value` the value from behind the found arg,
-            `None` if no value was found\n
+        If the script is called via the command line:\n
+        `python script.py -a1 "value1" --arg2 -f`\n
+        ...it would return an `Args` object where:
+        - `args.arg1.exists` is `True`, `args.arg1.value` is `"value1"`
+        - `args.arg2.exists` is `True`, `args.arg2.value` is `True` (flag present without value)
+        - `args.arg3.exists` is `False`, `args.arg3.value` is `None` (not present, no default)
+        - `args.arg4.exists` is `True`, `args.arg4.value` is `True` (flag present, overrides default)
+        - If an arg defined in `find_args` is *not* present in the command line:
+            - `exists` will be `False`
+            - `value` will be the specified `default` value, or `None` if no default was specified.\n
         ----------------------------------------------------------------
         Normally if `allow_spaces` is false, it will take a space as
         the end of an args value. If it is true, it will take spaces as
@@ -130,20 +166,40 @@ class Console:
         args = _sys.argv[1:]
         args_len = len(args)
         arg_lookup = {}
-        for arg_key, arg_group in find_args.items():
-            for arg in arg_group:
-                arg_lookup[arg] = arg_key
-        results = {key: {"exists": False, "value": None} for key in find_args}
+        results = {}
+        for alias, config in find_args.items():
+            flags = None
+            default_value = None
+            if isinstance(config, (list, tuple)):
+                flags = config
+            elif isinstance(config, dict):
+                if "flags" not in config:
+                    raise ValueError(f"Invalid configuration for alias '{alias}'. Dictionary must contain a 'flags' key.")
+                flags = config["flags"]
+                default_value = config.get("default")
+                if not isinstance(flags, (list, tuple)):
+                    raise ValueError(f"Invalid 'flags' for alias '{alias}'. Must be a list or tuple.")
+            else:
+                raise TypeError(f"Invalid configuration type for alias '{alias}'. Must be a list, tuple, or dict.")
+            results[alias] = {"exists": False, "value": default_value}
+            for flag in flags:
+                if flag in arg_lookup:
+                    raise ValueError(
+                        f"Duplicate flag '{flag}' found. It's assigned to both '{arg_lookup[flag]}' and '{alias}'."
+                    )
+                arg_lookup[flag] = alias
         i = 0
         while i < args_len:
             arg = args[i]
-            arg_key = arg_lookup.get(arg)
-            if arg_key:
-                results[arg_key]["exists"] = True
+            alias = arg_lookup.get(arg)
+            if alias:
+                results[alias]["exists"] = True
+                value_found_after_flag = False
                 if i + 1 < args_len and not args[i + 1].startswith("-"):
                     if not allow_spaces:
-                        results[arg_key]["value"] = String.to_type(args[i + 1])
+                        results[alias]["value"] = String.to_type(args[i + 1])
                         i += 1
+                        value_found_after_flag = True
                     else:
                         value_parts = []
                         j = i + 1
@@ -151,8 +207,11 @@ class Console:
                             value_parts.append(args[j])
                             j += 1
                         if value_parts:
-                            results[arg_key]["value"] = String.to_type(" ".join(value_parts))
+                            results[alias]["value"] = String.to_type(" ".join(value_parts))
                             i = j - 1
+                            value_found_after_flag = True
+                if not value_found_after_flag:
+                    results[alias]["value"] = True
             i += 1
         return Args(**results)
 
@@ -210,7 +269,7 @@ class Console:
         title_len, tab_len = len(title) + 4, _console_tabsize - ((len(title) + 4) % _console_tabsize)
         title_color = "_color" if not title_bg_color else Color.text_color_for_on_bg(title_bg_color)
         if format_linebreaks:
-            clean_prompt, removals = FormatCodes.remove_formatting(str(prompt), get_removals=True)
+            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))
@@ -384,7 +443,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.strip() for val in values for line in val.splitlines()]
+        lines = [line.rstrip() for val in values for line in 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
@@ -486,7 +545,7 @@ class Console:
         last_console_width = 0
 
         def update_display(console_width: int) -> None:
-            nonlocal select_all, last_line_count, last_console_width
+            nonlocal last_line_count, last_console_width
             lines = String.split_count(str(prompt) + (mask_char * len(result) if mask_char else result), console_width)
             line_count = len(lines)
             if (line_count > 1 or line_count < last_line_count) and not last_line_count == 1:

xulbux/xx_data.py

@@ -2,13 +2,14 @@ from ._consts_ import COLOR
 from .xx_format_codes import FormatCodes
 from .xx_string import String
 
-from typing import TypeAlias, Optional, Union
+from typing import TypeAlias, Optional, Union, Any
 import base64 as _base64
 import math as _math
 import re as _re
 
 
 DataStructure: TypeAlias = Union[list, tuple, set, frozenset, dict]
+IndexIterable: TypeAlias = Union[list, tuple, set, frozenset]
 
 
 class Data:
@@ -42,16 +43,23 @@ class Data:
     @staticmethod
     def chars_count(data: DataStructure) -> int:
         """The sum of all the characters amount including the keys in dictionaries."""
+        chars_count = 0
         if isinstance(data, dict):
-            return sum(len(str(k)) + len(str(v)) for k, v in data.items())
-        return sum(len(str(item)) for item in data)
+            for k, v in data.items():
+                chars_count += len(str(k)) + (Data.chars_count(v) if isinstance(v, DataStructure) else len(str(v)))
+        elif isinstance(data, IndexIterable):
+            for item in data:
+                chars_count += Data.chars_count(item) if isinstance(item, DataStructure) else len(str(item))
+        return chars_count
 
     @staticmethod
     def strip(data: DataStructure) -> DataStructure:
         """Removes leading and trailing whitespaces from the data structure's items."""
         if isinstance(data, dict):
-            return {k: Data.strip(v) for k, v in data.items()}
-        return type(data)(map(Data.strip, data))
+            return {k.strip(): Data.strip(v) if isinstance(v, DataStructure) else v.strip() for k, v in data.items()}
+        if isinstance(data, IndexIterable):
+            return type(data)(Data.strip(item) if isinstance(item, DataStructure) else item.strip() for item in data)
+        return data
 
     @staticmethod
     def remove_empty_items(data: DataStructure, spaces_are_empty: bool = False) -> DataStructure:
@@ -59,18 +67,15 @@ class Data:
         If `spaces_are_empty` is true, it will count items with only spaces as empty."""
         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)
-                )
+                k: (v if not isinstance(v, DataStructure) 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)):
+        if isinstance(data, IndexIterable):
             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, DataStructure) 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
 
@@ -78,17 +83,25 @@ class Data:
     def remove_duplicates(data: DataStructure) -> DataStructure:
         """Removes all duplicates from the data structure."""
         if isinstance(data, dict):
-            return {k: Data.remove_duplicates(v) for k, v in data.items()}
+            return {k: Data.remove_duplicates(v) if isinstance(v, DataStructure) else v for k, v in data.items()}
         if isinstance(data, (list, tuple)):
-            return type(data)(
-                Data.remove_duplicates(item) if isinstance(item, (list, tuple, set, frozenset, dict)) else item
-                for item in dict.fromkeys(data)
-            )
+            result = []
+            for item in data:
+                processed_item = Data.remove_duplicates(item) if isinstance(item, DataStructure) else item
+                is_duplicate = False
+                for existing_item in result:
+                    if processed_item == existing_item:
+                        is_duplicate = True
+                        break
+                if not is_duplicate:
+                    result.append(processed_item)
+            return type(data)(result)
         if isinstance(data, (set, frozenset)):
-            return type(data)(
-                Data.remove_duplicates(item) if isinstance(item, (list, tuple, set, frozenset, dict)) else item
-                for item in data
-            )
+            processed_elements = set()
+            for item in data:
+                processed_item = Data.remove_duplicates(item) if isinstance(item, DataStructure) else item
+                processed_elements.add(processed_item)
+            return type(data)(processed_elements)
         return data
 
     @staticmethod
@@ -161,13 +174,13 @@ class Data:
             else:
                 return None if s.lstrip().startswith(comment_start) else s.strip() or None
 
-        def process_item(item: any) -> any:
+        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
                 }
-            if isinstance(item, (list, tuple, set, frozenset)):
+            if isinstance(item, IndexIterable):
                 processed = (v for v in map(process_item, item) if v is not None)
                 return type(item)(processed)
             if isinstance(item, str):
@@ -283,7 +296,7 @@ class Data:
                         if ignore_not_found:
                             return None
                         raise KeyError(f"Key '{key}' not found in dict.")
-                elif isinstance(data_obj, (list, tuple, set, frozenset)):
+                elif isinstance(data_obj, IndexIterable):
                     try:
                         idx = int(key)
                         data_obj = list(data_obj)[idx]  # CONVERT TO LIST FOR INDEXING
@@ -310,7 +323,7 @@ class Data:
         return results if len(results) > 1 else results[0] if results else None
 
     @staticmethod
-    def get_value_by_path_id(data: DataStructure, path_id: str, get_key: bool = False) -> any:
+    def get_value_by_path_id(data: DataStructure, path_id: str, get_key: bool = False) -> Any:
         """Retrieves the value from `data` using the provided `path_id`.\n
         -------------------------------------------------------------------------------------------------
         Input your `data` along with a `path_id` that was created before using `Data.get_path_id()`.
@@ -319,7 +332,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: DataStructure, 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):
@@ -328,7 +341,7 @@ class Data:
                         return keys[idx]
                     parent = data
                     data = data[keys[idx]]
-                elif isinstance(data, (list, tuple, set, frozenset)):
+                elif isinstance(data, IndexIterable):
                     if i == len(path) - 1 and get_key:
                         if parent is None or not isinstance(parent, dict):
                             raise ValueError("Cannot get key from a non-dict parent")
@@ -342,45 +355,39 @@ 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: dict[str, Any]) -> 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
-        path ID that was created before using `Data.get_path_id()`, together with the
-        new value to be inserted where the path ID points to. The path ID and the new
-        value are separated by `sep`, which per default is `::`.\n
+        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"], ... }
+        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
         structure of `data` hasn't changed since creating the path ID to that value."""
 
-        def update_nested(data: DataStructure, path: list[int], value: any) -> DataStructure:
+        def update_nested(data: DataStructure, path: list[int], value: Any) -> DataStructure:
             if len(path) == 1:
                 if isinstance(data, dict):
-                    keys = list(data.keys())
-                    data = dict(data)
+                    keys, data = list(data.keys()), dict(data)
                     data[keys[path[0]]] = value
-                elif isinstance(data, (list, tuple, set, frozenset)):
-                    data = list(data)
+                elif isinstance(data, IndexIterable):
+                    was_t, data = type(data), list(data)
                     data[path[0]] = value
-                    data = type(data)(data)
+                    data = was_t(data)
             else:
                 if isinstance(data, dict):
-                    keys = list(data.keys())
-                    key = keys[path[0]]
-                    data = dict(data)
-                    data[key] = update_nested(data[key], path[1:], value)
-                elif isinstance(data, (list, tuple, set, frozenset)):
-                    data = list(data)
+                    keys, data = list(data.keys()), dict(data)
+                    data[keys[path[0]]] = update_nested(data[keys[path[0]]], path[1:], value)
+                elif isinstance(data, IndexIterable):
+                    was_t, data = type(data), list(data)
                     data[path[0]] = update_nested(data[path[0]], path[1:], value)
-                    data = type(data)(data)
+                    data = was_t(data)
             return 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 = [(path_id, new_val) for path_id, new_val in update_values.items()]
         if not valid_entries:
-            raise ValueError(f"No valid update_values found: {update_values}")
+            raise ValueError(f"No valid update_values found in dictionary: {update_values}")
         for path_id, new_val in valid_entries:
             path = Data.__sep_path_id(path_id)
             data = update_nested(data, path, new_val)
@@ -431,12 +438,12 @@ class Data:
             for k, v in punct_map.items()
         }
 
-        def format_value(value: any, current_indent: int = None) -> str:
+        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 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, (list, tuple, set, frozenset)):
+            elif current_indent is not None and isinstance(value, IndexIterable):
                 return format_sequence(value, current_indent + indent)
             elif isinstance(value, (bytes, bytearray)):
                 obj_dict = Data.serialize_bytes(value)

xulbux/xx_env_path.py

@@ -1,7 +1,3 @@
-"""
-Functions for modifying and checking the systems environment-variables (especially the PATH object).
-"""
-
 from .xx_path import Path
 
 import sys as _sys

xulbux/xx_file.py

@@ -1,25 +1,42 @@
 from .xx_string import String
-from .xx_path import Path
 
 import os as _os
 
 
 class SameContentFileExistsError(FileExistsError):
-    pass
+    ...
 
 
 class File:
 
     @staticmethod
-    def rename_extension(file: str, new_extension: str, camel_case_filename: bool = False) -> str:
+    def rename_extension(
+        file: str,
+        new_extension: str,
+        full_extension: bool = False,
+        camel_case_filename: bool = False,
+    ) -> str:
         """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
         If the `camel_case_filename` parameter is true, the filename will be made
         CamelCase in addition to changing the files extension."""
-        directory, filename_with_ext = _os.path.split(file)
-        filename = filename_with_ext.split(".")[0]
+        normalized_file = _os.path.normpath(file)
+        directory, filename_with_ext = _os.path.split(normalized_file)
+        if full_extension:
+            try:
+                first_dot_index = filename_with_ext.index('.')
+                filename = filename_with_ext[:first_dot_index]
+            except ValueError:
+                filename = filename_with_ext
+        else:
+            filename, _ = _os.path.splitext(filename_with_ext)
         if camel_case_filename:
             filename = String.to_camel_case(filename)
+        if new_extension and not new_extension.startswith('.'):
+            new_extension = '.' + new_extension
         return _os.path.join(directory, f"{filename}{new_extension}")
 
     @staticmethod
@@ -40,24 +57,3 @@ class File:
             f.write(content)
         full_path = _os.path.abspath(file)
         return full_path
-
-    @staticmethod
-    def extend_or_make_path(
-        file: str,
-        search_in: str | list[str] = None,
-        prefer_base_dir: bool = True,
-        correct_paths: bool = False,
-    ) -> str:
-        """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 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
-        ----------------------------------------------------------------------------------------------
-        If `correct_paths` is true, it is possible to have typos in the `search_in` path/s and it
-        will still find the file if it is under one of those paths."""
-        try:
-            return Path.extend(file, search_in, raise_error=True, correct_path=correct_paths)
-        except FileNotFoundError:
-            return _os.path.join(Path.script_dir, file) if prefer_base_dir else _os.path.join(_os.getcwd(), file)

xulbux/xx_format_codes.py

@@ -333,11 +333,16 @@ class FormatCodes:
         return ansi_string.replace(ANSI.char, ANSI.escaped_char)
 
     @staticmethod
-    def remove_ansi(ansi_string: str, get_removals: bool = False) -> str | tuple[str, tuple[tuple[int, str], ...]]:
+    def remove_ansi(
+        ansi_string: str,
+        get_removals: bool = False,
+        _ignore_linebreaks: bool = False,
+    ) -> str | tuple[str, tuple[tuple[int, str], ...]]:
         """Removes all ANSI codes from the string.\n
         --------------------------------------------------------------------------------------------------
         If `get_removals` is true, additionally to the cleaned string, a list of tuples will be returned.
-        Each tuple contains the position of the removed ansi code and the removed ansi code."""
+        Each tuple contains the position of the removed ansi code and the removed ansi code.\n
+        If `_ignore_linebreaks` is true, linebreaks will be ignored for the removal positions."""
         if get_removals:
             removals = []
 
@@ -348,18 +353,30 @@ class FormatCodes:
                 removals.append((start_pos, match.group()))
                 return ""
 
-            clean_string = _COMPILED["ansi_seq"].sub(replacement, ansi_string)
-            return clean_string, tuple(removals)
+            clean_string = _COMPILED["ansi_seq"].sub(
+                replacement,
+                ansi_string.replace("\n", "") if _ignore_linebreaks else ansi_string
+            )
+            return _COMPILED["ansi_seq"].sub("", ansi_string) if _ignore_linebreaks else clean_string, tuple(removals)
         else:
             return _COMPILED["ansi_seq"].sub("", ansi_string)
 
     @staticmethod
-    def remove_formatting(string: str, get_removals: bool = False) -> str | tuple[str, tuple[tuple[int, str], ...]]:
+    def remove_formatting(
+        string: str,
+        get_removals: bool = False,
+        _ignore_linebreaks: bool = False,
+    ) -> str | tuple[str, tuple[tuple[int, str], ...]]:
         """Removes all formatting codes from the string.\n
-        ----------------------------------------------------------------------------------------------------
+        ---------------------------------------------------------------------------------------------------
         If `get_removals` is true, additionally to the cleaned string, a list of tuples will be returned.
-        Each tuple contains the position of the removed formatting code and the removed formatting code."""
-        return FormatCodes.remove_ansi(FormatCodes.to_ansi(string), get_removals=get_removals)
+        Each tuple contains the position of the removed formatting code and the removed formatting code.\n
+        If `_ignore_linebreaks` is true, linebreaks will be ignored for the removal positions."""
+        return FormatCodes.remove_ansi(
+            FormatCodes.to_ansi(string),
+            get_removals=get_removals,
+            _ignore_linebreaks=_ignore_linebreaks,
+        )
 
     @staticmethod
     def __config_console() -> None: