xulbux 1.6.1__py3-none-any.whl

xulbux/xx_file.py

@@ -0,0 +1,65 @@
+from .xx_string import String
+from .xx_path import Path
+
+import os as _os
+
+
+class File:
+
+    @staticmethod
+    def rename_extension(
+        file: str,
+        new_extension: str,
+        camel_case_filename: bool = False,
+    ) -> str:
+        """Rename the extension of a file.\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]
+        if camel_case_filename:
+            filename = String.to_camel_case(filename)
+        return _os.path.join(directory, f"{filename}{new_extension}")
+
+    @staticmethod
+    def create(
+        file: str,
+        content: str = "",
+        force: bool = False,
+    ) -> str:
+        """Create a file with ot without content.\n
+        ------------------------------------------------------------------------
+        The function will throw a `FileExistsError` if the file already exists.
+        To always overwrite the file, set the `force` parameter to `True`."""
+        if _os.path.exists(file) and not force:
+            with open(file, "r", encoding="utf-8") as existing_file:
+                existing_content = existing_file.read()
+                if existing_content == content:
+                    raise FileExistsError("Already created this file. (nothing changed)")
+            raise FileExistsError("File already exists.")
+        with open(file, "w", encoding="utf-8") as f:
+            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 the above 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.get(base_dir=True), file) if prefer_base_dir else _os.path.join(_os.getcwd(), file)

xulbux/xx_format_codes.py

@@ -0,0 +1,305 @@
+"""
+Functions to be able to use special (easy) formatting codes directly inside some message (string).\n
+These codes, when used within following functions, will change the look of log within the console:
+- `FormatCodes.print()` (print a special format-codes containing string)
+- `FormatCodes.input()` (input with a special format-codes containing prompt)
+- `FormatCodes.to_ansi()` (transform all special format-codes into ANSI codes in a string)\n
+--------------------------------------------------------------------------------------------------------------------
+How to change the text format and color?\n
+Example string with formatting codes:
+```string
+[bold]This is bold text, [#F08]which is pink now [black|BG:#FF0088] and now it changed`
+to black with a pink background. [_]And this is the boring text, where everything is reset.
+```
+⇾ Instead of writing the formats all separate `[…][…][…]` you can join them like this `[…|…|…]`\n
+--------------------------------------------------------------------------------------------------------------------
+You can also automatically reset a certain format, behind text like shown in the following example:
+```string
+This is normal text [b](which is bold now) but now it was automatically reset to normal.
+```
+This will only reset formats, that have a reset listed below. Colors and BG-colors won't be reset.\n
+This is what will happen, if you use it with a color-format:
+```string
+[cyan]This is cyan text [b](which is bold now.) Now it's not bold any more but still cyan.
+```
+If you want to ignore the `()` brackets you can put a `\\` or `/` between:
+```string
+[cyan]This is cyan text [b]/(which is bold now.) And now it is still bold and cyan.
+```
+⇾ To see these examples in action, you can put them into the `FormatCodes.print()` function.\n
+--------------------------------------------------------------------------------------------------------------------
+All possible formatting codes:
+- HEX colors:  `[#F08]` or `[#FF0088]` (with or without leading #)
+- RGB colors:  `[rgb(255, 0, 136)]`
+- bright colors:  `[bright:#F08]`
+- background colors:  `[BG:#F08]`
+- standard cmd colors:
+  - `[black]`
+  - `[red]`
+  - `[green]`
+  - `[yellow]`
+  - `[blue]`
+  - `[magenta]`
+  - `[cyan]`
+  - `[white]`
+- bright cmd colors: `[bright:black]` or `[br:black]`, `[bright:red]` or `[br:red]`, ...
+- background cmd colors: `[BG:black]`, `[BG:red]`, ...
+- bright background cmd colors: `[BG:bright:black]` or `[BG:br:black]`, `[BG:bright:red]` or `[BG:br:red]`, ...\n
+  ⇾ The order of `BG:` and `bright:` or `br:` does not matter.
+- text formats:
+  - `[bold]` or `[b]`
+  - `[dim]`
+  - `[italic]` or `[i]`
+  - `[underline]` or `[u]`
+  - `[inverse]`, `[invert]` or `[in]`
+  - `[hidden]`, `[hide]` or `[h]`
+  - `[strikethrough]` or `[s]`
+  - `[double-underline]` or `[du]`
+- specific reset:  `[_bold]` or `[_b]`, `[_dim]`, ... or `[_color]` or `[_c]`, `[_background]` or `[_bg]`
+- total reset: `[_]` (only if no `default_color` is set, otherwise see ↓ )
+--------------------------------------------------------------------------------------------------------------------
+Special formatting when param `default_color` is set to a color:
+- `[*]` will reset everything, just like `[_]`, but the text-color will remain in `default_color`
+- `[*color]` will reset the text-color, just like `[_color]`, but then also make it `default_color`
+- `[default]` will just color the text in `default_color`,
+- `[BG:default]` will color the background in `default_color`\n
+Unlike the standard cmd colors, the default color can be changed by using the following modifiers:
+- `[l]` will lighten the `default_color` text by `brightness_steps`%
+- `[ll]` will lighten the `default_color` text by `2 × brightness_steps`%
+- `[lll]` will lighten the `default_color` text by `3 × brightness_steps`%
+- ... etc. Same thing for darkening:
+- `[d]` will darken the `default_color` text by `brightness_steps`%
+- `[dd]` will darken the `default_color` text by `2 × brightness_steps`%
+- `[ddd]` will darken the `default_color` text by `3 × brightness_steps`%
+- ... etc.\n
+Per default, you can also use `+` and `-` to get lighter and darker `default_color` versions.
+"""
+
+from ._consts_ import ANSI
+from .xx_string import String
+from .xx_regex import Regex
+from .xx_color import *
+
+from functools import lru_cache
+import ctypes as _ctypes
+import regex as _rx
+import sys as _sys
+import re as _re
+
+
+COMPILED = {  # PRECOMPILE REGULAR EXPRESSIONS
+    "*": _re.compile(r"\[\s*([^]_]*?)\s*\*\s*([^]_]*?)\]"),
+    "*color": _re.compile(r"\[\s*([^]_]*?)\s*\*color\s*([^]_]*?)\]"),
+    "format": _rx.compile(
+        Regex.brackets("[", "]", is_group=True) + r"(?:\s*([/\\]?)\s*" + Regex.brackets("(", ")", is_group=True) + r")?"
+    ),
+    "bg?_default": _re.compile(r"(?i)((?:BG\s*:)?)\s*default"),
+    "bg_default": _re.compile(r"(?i)BG\s*:\s*default"),
+    "modifier": _re.compile(
+        rf'(?i)((?:BG\s*:)?)\s*({"|".join([f"{_re.escape(m)}+" for m in ANSI.modifier["lighten"] + ANSI.modifier["darken"]])})$'
+    ),
+    "rgb": _re.compile(r"(?i)^\s*(BG\s*:)?\s*(?:rgb|rgba)?\s*\(?\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)?\s*$"),
+    "hex": _re.compile(r"(?i)^\s*(BG\s*:)?\s*(?:#|0x)?([0-9A-F]{6}|[0-9A-F]{3})\s*$"),
+}
+
+
+class FormatCodes:
+
+    @staticmethod
+    def print(
+        *values: object,
+        default_color: hexa | rgba = None,
+        brightness_steps: int = 20,
+        sep: str = " ",
+        end: str = "\n",
+        flush: bool = True,
+    ) -> None:
+        FormatCodes.__config_console()
+        _sys.stdout.write(FormatCodes.to_ansi(sep.join(map(str, values)) + end, default_color, brightness_steps))
+        if flush:
+            _sys.stdout.flush()
+
+    @staticmethod
+    def input(
+        prompt: object = "",
+        default_color: hexa | rgba = None,
+        brightness_steps: int = 20,
+    ) -> str:
+        FormatCodes.__config_console()
+        return input(FormatCodes.to_ansi(prompt, default_color, brightness_steps))
+
+    @staticmethod
+    def to_ansi(
+        string: str, default_color: hexa | rgba = None, brightness_steps: int = 20, _default_start: bool = True
+    ) -> str:
+        result, bg_kwd, color_pref = string, {"bg"}, {"br", "bright"}
+
+        if Color.is_valid_rgba(default_color, False):
+            use_default = True
+        elif Color.is_valid_hexa(default_color, False):
+            use_default, default_color = True, Color.to_rgba(default_color)
+        else:
+            use_default = False
+        if use_default:
+            string = COMPILED["*"].sub(r"[\1_|default\2]", string)  # REPLACE `[…|*|…]` WITH `[…|_|default|…]`
+            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)
+
+        def replace_keys(match: _re.Match) -> str:
+            formats = match.group(1)
+            escaped = match.group(2)
+            auto_reset_txt = match.group(3)
+            if auto_reset_txt and auto_reset_txt.count("[") > 0 and auto_reset_txt.count("]") > 0:
+                auto_reset_txt = FormatCodes.to_ansi(auto_reset_txt, default_color, brightness_steps, False)
+            if not formats:
+                return match.group(0)
+            if formats.count("[") > 0 and formats.count("]") > 0:
+                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
+            ]
+            if auto_reset_txt and not escaped:
+                reset_keys = []
+                for k in format_keys:
+                    k_lower = k.lower()
+                    k_parts = k_lower.split(":")
+                    k_set = set(k_parts)
+                    if bg_kwd & k_set and len(k_parts) <= 3:
+                        if k_set & color_pref:
+                            for i in range(len(k)):
+                                if is_valid_color(k[i:]):
+                                    reset_keys.extend(["_bg", "_color"])
+                                    break
+                        else:
+                            for i in range(len(k)):
+                                if is_valid_color(k[i:]):
+                                    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 color_pref
+                    ):
+                        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}"
+                    )
+                ]
+            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
+            ):
+                return match.group(0)
+            return (
+                "".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))
+            )
+
+        result = "\n".join(COMPILED["format"].sub(replace_keys, line) for line in string.split("\n"))
+        return (FormatCodes.__get_default_ansi(default_color) if _default_start else "") + result if use_default else result
+
+    @staticmethod
+    def escape_ansi(ansi_string: str, escaped_char: str = ANSI.char_esc) -> str:
+        """Makes the string printable with the ANSI formats visible."""
+        return ansi_string.replace(ANSI.char, escaped_char)
+
+    @staticmethod
+    @lru_cache(maxsize=64)
+    def __config_console() -> None:
+        _sys.stdout.flush()
+        kernel32 = _ctypes.windll.kernel32
+        h = kernel32.GetStdHandle(-11)
+        mode = _ctypes.c_ulong()
+        kernel32.GetConsoleMode(h, _ctypes.byref(mode))
+        kernel32.SetConsoleMode(h, mode.value | 0x0004)
+
+    @staticmethod
+    def __get_default_ansi(
+        default_color: tuple,
+        format_key: str = None,
+        brightness_steps: int = None,
+        _modifiers: tuple[str, str] = (ANSI.modifier["lighten"], ANSI.modifier["darken"]),
+    ) -> str | None:
+        if not brightness_steps or (format_key and COMPILED["bg?_default"].search(format_key)):
+            return (ANSI.seq_bg_color if format_key and COMPILED["bg_default"].search(format_key) else ANSI.seq_color).format(
+                *default_color[:3]
+            )
+        if not (format_key in _modifiers[0] or format_key in _modifiers[1]):
+            return None
+        match = COMPILED["modifier"].match(format_key)
+        if not match:
+            return None
+        is_bg, modifiers = match.groups()
+        adjust = 0
+        for mod in _modifiers[0] + _modifiers[1]:
+            adjust = String.single_char_repeats(modifiers, mod)
+            if adjust and adjust > 0:
+                modifiers = mod
+                break
+        if adjust == 0:
+            return None
+        elif modifiers in _modifiers[0]:
+            new_rgb = Color.adjust_lightness(default_color, (brightness_steps / 100) * adjust)
+        elif modifiers in _modifiers[1]:
+            new_rgb = Color.adjust_lightness(default_color, -(brightness_steps / 100) * adjust)
+        return (ANSI.seq_bg_color if is_bg else ANSI.seq_color).format(*new_rgb[:3])
+
+    @staticmethod
+    def __get_replacement(format_key: str, default_color: 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)
+        _format_key, format_key = format_key, (  # NORMALIZE THE FORMAT KEY (+ SAVE ORIGINAL)
+            "bg:" if "bg" in (parts := format_key.replace(" ", "").lower().split(":")) else ""
+        ) + ("bright:" if any(x in parts for x in ("bright", "br")) else "") + ":".join(
+            p for p in parts if p not in ("bg", "bright", "br")
+        )
+        if use_default:
+            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:
+                return ANSI.seq().format(
+                    next(
+                        (
+                            v
+                            for k, v in ANSI.codes_map.items()
+                            if format_key == k or (isinstance(k, tuple) and format_key in k)
+                        ),
+                        None,
+                    )
+                )
+        rgb_match = _re.match(COMPILED["rgb"], format_key)
+        hex_match = _re.match(COMPILED["hex"], format_key)
+        try:
+            if rgb_match:
+                is_bg = rgb_match.group(1)
+                r, g, b = map(int, rgb_match.groups()[1:])
+                if Color.is_valid_rgba((r, g, b)):
+                    return ANSI.seq_bg_color.format(r, g, b) if is_bg else ANSI.seq_color.format(r, g, b)
+            elif hex_match:
+                is_bg = hex_match.group(1)
+                rgb = Color.to_rgba(hex_match.group(2))
+                return (
+                    ANSI.seq_bg_color.format(rgb[0], rgb[1], rgb[2])
+                    if is_bg
+                    else ANSI.seq_color.format(rgb[0], rgb[1], rgb[2])
+                )
+        except Exception:
+            pass
+        return _format_key

xulbux/xx_json.py

@@ -0,0 +1,106 @@
+from .xx_data import Data
+from .xx_file import File
+
+import json as _json
+import os as _os
+
+
+class Json:
+
+    @staticmethod
+    def read(
+        json_file: str,
+        comment_start: str = ">>",
+        comment_end: str = "<<",
+        return_original: bool = False,
+    ) -> dict | tuple[dict, dict]:
+        """Read JSON files, ignoring comments.\n
+        -------------------------------------------------------------------------
+        If only `comment_start` is found at the beginning of an item,
+        the whole item is counted as a comment and therefore ignored.
+        If `comment_start` and `comment_end` are found inside an item,
+        the the section from `comment_start` to `comment_end` is ignored.
+        If `return_original` is set to `True`, the original JSON is returned
+        additionally. (returns: `[processed_json, original_json]`)"""
+        if not json_file.endswith(".json"):
+            json_file += ".json"
+        file_path = File.extend_or_make_path(json_file, prefer_base_dir=True)
+        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)
+        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
+
+    @staticmethod
+    def create(
+        content: dict,
+        new_file: str = "config",
+        indent: int = 2,
+        compactness: int = 1,
+        force: bool = False,
+    ) -> str:
+        if not new_file.endswith(".json"):
+            new_file += ".json"
+        file_path = File.extend_or_make_path(new_file, prefer_base_dir=True)
+        if _os.path.exists(file_path) and not force:
+            with open(file_path, "r", encoding="utf-8") as existing_f:
+                existing_content = _json.load(existing_f)
+                if existing_content == content:
+                    raise FileExistsError("Already created this file. (nothing changed)")
+            raise FileExistsError("File already exists.")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(Data.to_str(content, indent, compactness, as_json=True))
+        full_path = _os.path.abspath(file_path)
+        return full_path
+
+    @staticmethod
+    def update(
+        json_file: str,
+        update_values: str | list[str],
+        comment_start: str = ">>",
+        comment_end: str = "<<",
+        sep: tuple[str, str] = ("->", "::"),
+    ) -> None:
+        """Function to easily update single/multiple values inside JSON files.\n
+        ------------------------------------------------------------------------------------------------------
+        The param `json_file` is the path to the JSON file or just the name of the JSON file to be updated.\n
+        ------------------------------------------------------------------------------------------------------
+        The param `update_values` is a sort of path (or a list of paths) to the value/s to be updated, with
+        the new value at the end of the path.\n
+        In this example:
+        ```python
+        {
+          'healthy': {
+            'fruit': ['apples', 'bananas', 'oranges'],
+            'vegetables': ['carrots', 'broccoli', 'celery']
+          }
+        }
+        ```
+        ... if you want to change the value of `'apples'` to `'strawberries'`, `update_values` would be
+        `healthy->fruit->apples::strawberries` or if you don't know that the value to update is `apples` you
+        can also use the position of the value, so `healthy->fruit->0::strawberries`.\n
+        ⇾ If the path from `update_values` doesn't exist, it will be created.\n
+        ------------------------------------------------------------------------------------------------------
+        If only `comment_start` is found at the beginning of an item, the whole item is counted as a comment
+        and therefore ignored. If `comment_start` and `comment_end` are found inside an item, the the section
+        from `comment_start` to `comment_end` is ignored."""
+        if isinstance(update_values, str):
+            update_values = [update_values]
+        valid_entries = [
+            (parts[0].strip(), parts[1])
+            for update_value in update_values
+            if len(parts := update_value.split(str(sep[1]).strip())) == 2
+        ]
+        value_paths, new_values = zip(*valid_entries) if valid_entries else ([], [])
+        processed_data, data = Json.read(json_file, comment_start, comment_end, return_original=True)
+        update = []
+        for value_path, new_value in zip(value_paths, new_values):
+            path_id = Data.get_path_id(processed_data, value_path)
+            update.append(f"{path_id}::{new_value}")
+        updated = Data.set_value_by_path_id(data, update)
+        Json.create(updated, json_file, force=True)

xulbux/xx_path.py

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