stouputils 1.12.2__py3-none-any.whl → 1.13.0__py3-none-any.whl

stouputils/stouputils/image.pyi

@@ -0,0 +1,172 @@
+import numpy as np
+from .io import super_open as super_open
+from .print import debug as debug, info as info
+from PIL import Image
+from collections.abc import Callable
+from numpy.typing import NDArray
+from typing import Any, TypeVar
+
+PIL_Image_or_NDArray = TypeVar('PIL_Image_or_NDArray', bound='Image.Image | NDArray[np.number]')
+
+def image_resize[PIL_Image_or_NDArray](image: PIL_Image_or_NDArray, max_result_size: int, resampling: Image.Resampling | None = None, min_or_max: Callable[[int, int], int] = ..., return_type: type[PIL_Image_or_NDArray] | str = 'same', keep_aspect_ratio: bool = True) -> Any:
+    ''' Resize an image while preserving its aspect ratio by default.
+\tScales the image so that its largest dimension equals max_result_size.
+
+\tArgs:
+\t\timage             (Image.Image | np.ndarray): The image to resize.
+\t\tmax_result_size   (int):                      Maximum size for the largest dimension.
+\t\tresampling        (Image.Resampling | None):  PIL resampling filter to use (default: Image.Resampling.LANCZOS).
+\t\tmin_or_max        (Callable):                 Function to use to get the minimum or maximum of the two ratios.
+\t\treturn_type       (type | str):               Type of the return value (Image.Image, np.ndarray, or "same" to match input type).
+\t\tkeep_aspect_ratio (bool):                     Whether to keep the aspect ratio.
+\tReturns:
+\t\tImage.Image | NDArray[np.number]: The resized image with preserved aspect ratio.
+\tExamples:
+\t\t>>> # Test with (height x width x channels) numpy array
+\t\t>>> import numpy as np
+\t\t>>> array = np.random.randint(0, 255, (100, 50, 3), dtype=np.uint8)
+\t\t>>> image_resize(array, 100).shape
+\t\t(100, 50, 3)
+\t\t>>> image_resize(array, 100, min_or_max=max).shape
+\t\t(100, 50, 3)
+\t\t>>> image_resize(array, 100, min_or_max=min).shape
+\t\t(200, 100, 3)
+
+\t\t>>> # Test with PIL Image
+\t\t>>> from PIL import Image
+\t\t>>> pil_image: Image.Image = Image.new(\'RGB\', (200, 100))
+\t\t>>> image_resize(pil_image, 50).size
+\t\t(50, 25)
+\t\t>>> # Test with different return types
+\t\t>>> resized_array = image_resize(array, 50, return_type=np.ndarray)
+\t\t>>> isinstance(resized_array, np.ndarray)
+\t\tTrue
+\t\t>>> resized_array.shape
+\t\t(50, 25, 3)
+\t\t>>> # Test with different resampling methods
+\t\t>>> image_resize(pil_image, 50, resampling=Image.Resampling.NEAREST).size
+\t\t(50, 25)
+\t'''
+def auto_crop[PIL_Image_or_NDArray](image: PIL_Image_or_NDArray, mask: NDArray[np.bool_] | None = None, threshold: int | float | Callable[[NDArray[np.number]], int | float] | None = None, return_type: type[PIL_Image_or_NDArray] | str = 'same', contiguous: bool = True) -> Any:
+    ''' Automatically crop an image to remove zero or uniform regions.
+
+\tThis function crops the image to keep only the region where pixels are non-zero
+\t(or above a threshold). It can work with a mask or directly analyze the image.
+
+\tArgs:
+\t\timage       (Image.Image | NDArray):\t  The image to crop.
+\t\tmask        (NDArray[bool] | None):       Optional binary mask indicating regions to keep.
+\t\tthreshold   (int | float | Callable):     Threshold value or function (default: np.min).
+\t\treturn_type (type | str):                 Type of the return value (Image.Image, NDArray[np.number], or "same" to match input type).
+\t\tcontiguous  (bool):                       If True (default), crop to bounding box. If False, remove entire rows/columns with no content.
+\tReturns:
+\t\tImage.Image | NDArray[np.number]: The cropped image.
+
+\tExamples:
+\t\t>>> # Test with numpy array with zeros on edges
+\t\t>>> import numpy as np
+\t\t>>> array = np.zeros((100, 100, 3), dtype=np.uint8)
+\t\t>>> array[20:80, 30:70] = 255  # White rectangle in center
+\t\t>>> cropped = auto_crop(array, return_type=np.ndarray)
+\t\t>>> cropped.shape
+\t\t(60, 40, 3)
+
+\t\t>>> # Test with custom mask
+\t\t>>> mask = np.zeros((100, 100), dtype=bool)
+\t\t>>> mask[10:90, 10:90] = True
+\t\t>>> cropped_with_mask = auto_crop(array, mask=mask, return_type=np.ndarray)
+\t\t>>> cropped_with_mask.shape
+\t\t(80, 80, 3)
+
+\t\t>>> # Test with PIL Image
+\t\t>>> from PIL import Image
+\t\t>>> pil_image = Image.new(\'RGB\', (100, 100), (0, 0, 0))
+\t\t>>> from PIL import ImageDraw
+\t\t>>> draw = ImageDraw.Draw(pil_image)
+\t\t>>> draw.rectangle([25, 25, 75, 75], fill=(255, 255, 255))
+\t\t>>> cropped_pil = auto_crop(pil_image)
+\t\t>>> cropped_pil.size
+\t\t(51, 51)
+
+\t\t>>> # Test with threshold
+\t\t>>> array_gray = np.ones((100, 100), dtype=np.uint8) * 10
+\t\t>>> array_gray[20:80, 30:70] = 255
+\t\t>>> cropped_threshold = auto_crop(array_gray, threshold=50, return_type=np.ndarray)
+\t\t>>> cropped_threshold.shape
+\t\t(60, 40)
+
+\t\t>>> # Test with callable threshold (using lambda to avoid min value)
+\t\t>>> array_gray2 = np.ones((100, 100), dtype=np.uint8) * 10
+\t\t>>> array_gray2[20:80, 30:70] = 255
+\t\t>>> cropped_max = auto_crop(array_gray2, threshold=lambda x: 50, return_type=np.ndarray)
+\t\t>>> cropped_max.shape
+\t\t(60, 40)
+
+\t>>> # Test with non-contiguous crop
+\t>>> array_sparse = np.zeros((100, 100, 3), dtype=np.uint8)
+\t>>> array_sparse[10, 10] = 255
+\t>>> array_sparse[50, 50] = 255
+\t>>> array_sparse[90, 90] = 255
+\t>>> cropped_contiguous = auto_crop(array_sparse, contiguous=True, return_type=np.ndarray)
+\t>>> cropped_contiguous.shape  # Bounding box from (10,10) to (90,90)
+\t(81, 81, 3)
+\t>>> cropped_non_contiguous = auto_crop(array_sparse, contiguous=False, return_type=np.ndarray)
+\t>>> cropped_non_contiguous.shape  # Only rows/cols 10, 50, 90
+\t(3, 3, 3)
+
+\t>>> # Test with 3D crop on depth dimension
+\t>>> array_3d = np.zeros((50, 50, 10), dtype=np.uint8)
+\t>>> array_3d[10:40, 10:40, 2:8] = 255  # Content only in depth slices 2-7
+\t>>> cropped_3d = auto_crop(array_3d, contiguous=True, return_type=np.ndarray)
+\t>>> cropped_3d.shape  # Should crop all 3 dimensions
+\t(30, 30, 6)
+\t'''
+def numpy_to_gif(path: str, array: NDArray[np.integer | np.floating | np.bool_], duration: int = 100, loop: int = 0, mkdir: bool = True, **kwargs: Any) -> None:
+    ''' Generate a \'.gif\' file from a numpy array for 3D/4D visualization.
+
+\tArgs:
+\t\tpath     (str):     Path to the output .gif file.
+\t\tarray    (NDArray): Numpy array to be dumped (must be 3D or 4D).
+\t\t\t3D: (depth, height, width) - e.g. (64, 1024, 1024)
+\t\t\t4D: (depth, height, width, channels) - e.g. (50, 64, 1024, 3)
+\t\tduration (int):     Duration between frames in milliseconds.
+\t\tloop     (int):     Number of loops (0 = infinite).
+\t\tmkdir    (bool):    Create the directory if it does not exist.
+\t\t**kwargs (Any):     Additional keyword arguments for PIL.Image.save().
+
+\tExamples:
+
+\t\t.. code-block:: python
+
+\t\t\t> # 3D array example
+\t\t\t> array = np.random.randint(0, 256, (10, 100, 100), dtype=np.uint8)
+\t\t\t> numpy_to_gif("output_10_frames_100x100.gif", array, duration=200, loop=0)
+
+\t\t\t> # 4D array example (batch of 3D images)
+\t\t\t> array_4d = np.random.randint(0, 256, (5, 10, 100, 3), dtype=np.uint8)
+\t\t\t> numpy_to_gif("output_50_frames_100x100.gif", array_4d, duration=200)
+
+\t\t\t> total_duration = 1000  # 1 second
+\t\t\t> numpy_to_gif("output_1s.gif", array, duration=total_duration // len(array))
+\t'''
+def numpy_to_obj(path: str, array: NDArray[np.integer | np.floating | np.bool_], threshold: float = 0.5, step_size: int = 1, pad_array: bool = True, verbose: int = 0) -> None:
+    ''' Generate a \'.obj\' file from a numpy array for 3D visualization using marching cubes.
+
+\tArgs:
+\t\tpath      (str):     Path to the output .obj file.
+\t\tarray     (NDArray): Numpy array to be dumped (must be 3D).
+\t\tthreshold (float):   Threshold level for marching cubes (0.5 for binary data).
+\t\tstep_size (int):     Step size for marching cubes (higher = simpler mesh, faster generation).
+\t\tpad_array (bool):    If True, pad array with zeros to ensure closed volumes for border cells.
+\t\tverbose   (int):     Verbosity level (0 = no output, 1 = some output, 2 = full output).
+
+\tExamples:
+
+\t\t.. code-block:: python
+
+\t\t\t> array = np.random.rand(64, 64, 64) > 0.5  # Binary volume
+\t\t\t> numpy_to_obj("output_mesh.obj", array, threshold=0.5, step_size=2, pad_array=True, verbose=1)
+
+\t\t\t> array = my_3d_data  # Some 3D numpy array (e.g. human lung scan)
+\t\t\t> numpy_to_obj("output_mesh.obj", array, threshold=0.3)
+\t'''

stouputils/stouputils/installer/__init__.pyi

@@ -0,0 +1,5 @@
+from .common import *
+from .downloader import *
+from .linux import *
+from .main import *
+from .windows import *

stouputils/stouputils/installer/common.pyi

@@ -0,0 +1,39 @@
+from ..print import warning as warning
+from typing import Literal
+
+def prompt_for_path(prompt_message: str, default_path: str) -> str:
+    """ Prompt the user to override a default path.
+
+\tArgs:
+\t\tprompt_message (str): The message to display to the user.
+\t\tdefault_path   (str): The default path to suggest.
+
+\tReturns:
+\t\tstr: The path entered by the user, or the default path if they pressed Enter.
+\t"""
+def ask_install_type(ask_global: int, default_local_path: str, default_global_path: str | None) -> Literal['g', 'l']:
+    ''' Determine the installation type (global \'g\' or local \'l\') based on user input.
+
+\tArgs:
+\t\task_global          (int):           0 = ask, 1 = force global, 2 = force local.
+\t\tdefault_local_path  (str):           The default local path.
+\t\tdefault_global_path (str | None):    The default global path (if applicable).
+
+\tReturns:
+\t\tLiteral["g", "l"]: \'g\' for global install, \'l\' for local install.
+
+\tExamples:
+\t\t.. code-block:: python
+
+\t\t\t> # Ask the user while providing default paths
+\t\t\t> install_choice: str = ask_install_type(0, f"{os.getcwd()}/MyProgram", "C:\\Program Files\\MyProgram")
+\t\t\tg
+
+\t\t\t> # Don\'t ask, force global
+\t\t\t> install_choice: str = ask_install_type(1, ...)
+\t\t\tg
+
+\t\t\t> # Don\'t ask, force local
+\t\t\t> install_choice: str = ask_install_type(2, ...)
+\t\t\tl
+\t'''

stouputils/stouputils/installer/downloader.pyi

@@ -0,0 +1,24 @@
+from ..print import info as info, warning as warning
+from .main import install_program as install_program
+
+def download_executable(download_urls: dict[str, str], program_name: str, append_to_path: str = '') -> bool:
+    """ Ask the user if they want to download the program (ex: waifu2x-ncnn-vulkan).
+\tIf yes, try to download the program from the GitHub releases page.
+
+\tArgs:
+\t\tdownload_urls  (dict[str, str]):  The URLs to download the program from.
+\t\tprogram_name   (str):             The name of the program to download.
+
+\tReturns:
+\t\tbool: True if the program is now ready to use, False otherwise.
+\t"""
+def check_executable(executable: str, executable_help_text: str, download_urls: dict[str, str], append_to_path: str = '') -> None:
+    ''' Check if the executable exists, optionally download it if it doesn\'t.
+
+\tArgs:
+\t\texecutable            (str):             The path to the executable.
+\t\texecutable_help_text  (str):             The help text to check for in the executable\'s output.
+\t\tdownload_urls         (dict[str, str]):  The URLs to download the executable from.
+\t\tappend_to_path        (str):             The path to append to the executable\'s path.
+\t\t\t(ex: "bin" if executables are in the bin folder)
+\t'''

stouputils/stouputils/installer/linux.pyi

@@ -0,0 +1,39 @@
+from ..decorators import LogLevels as LogLevels, handle_error as handle_error
+from ..io import clean_path as clean_path
+from ..print import debug as debug, info as info, warning as warning
+from .common import ask_install_type as ask_install_type, prompt_for_path as prompt_for_path
+
+def add_to_path_linux(install_path: str) -> bool:
+    """ Suggest how to add install_path to PATH on Linux.
+
+\tChecks the current shell and provides instructions for adding the path
+\tto the appropriate configuration file (e.g., .bashrc, .zshrc, config.fish).
+
+\tArgs:
+\t\tinstall_path (str): The path to add to the PATH environment variable.
+
+\tReturns:
+\t\tbool: True if instructions were provided, False otherwise (e.g., unknown shell).
+\t"""
+def check_admin_linux() -> bool:
+    """ Check if the script is running with root privileges on Linux/macOS.
+
+\tReturns:
+\t\tbool: True if the effective user ID is 0 (root), False otherwise.
+\t"""
+def get_install_path_linux(program_name: str, ask_global: int = 0, add_path: bool = True, append_to_path: str = '', default_global: str = '/usr/local/bin') -> str:
+    ''' Get the installation path for the program on Linux/macOS.
+
+\tArgs:
+\t\tprogram_name   (str):   The name of the program to install.
+\t\task_global     (int):   0 = ask for anything, 1 = install globally, 2 = install locally
+\t\tadd_path       (bool):  Whether to add the program to the PATH environment variable. (Only if installed globally)
+\t\tappend_to_path (str):   String to append to the installation path when adding to PATH.
+\t\t\t(ex: "bin" if executables are in the bin folder)
+\t\tdefault_global (str):   The default global installation path.
+\t\t\t(Default is "/usr/local/bin" which is the most common location for executables on Linux/macOS,
+\t\t\tcould be "/opt" or any other directory)
+
+\tReturns:
+\t\tstr: The chosen installation path, or an empty string if installation is cancelled.
+\t'''

stouputils/stouputils/installer/main.pyi

@@ -0,0 +1,57 @@
+from .common import *
+from .linux import *
+from .windows import *
+from ..decorators import LogLevels as LogLevels, handle_error as handle_error
+from ..print import info as info, warning as warning
+from collections.abc import Callable as Callable
+
+def extract_archive(extraction_path: str, temp_dir: str, extract_func: Callable[[str], None], get_file_list_func: Callable[[], list[str]]) -> None:
+    """ Helper function to extract archive files with consistent handling.
+
+\tArgs:
+\t\textraction_path     (str): Path where files should be extracted
+\t\ttemp_dir            (str): Temporary directory for intermediate extraction
+\t\textract_func        (Callable[[str], None]): Function to extract the archive
+\t\tget_file_list_func  (Callable[[], list[str]]): Function to get the list of files in the archive
+\t"""
+def get_install_path(program_name: str, platform_str: str = ..., ask_global: int = 0, add_path: bool = True, append_to_path: str = '') -> str:
+    ''' Get the installation path for the program on the current platform.
+
+\tArgs:
+\t\tprogram_name  (str):  The name of the program to install.
+\t\tplatform_str  (str):  The platform to get the installation path for.
+\t\task_global    (int):  Whether to ask the user for a path, 0 = ask, 1 = install globally, 2 = install locally.
+\t\tadd_path      (bool): Whether to add the program to the PATH environment variable.
+\t\tappend_to_path (str):  String to append to the installation path when adding to PATH.
+\t\t\t(ex: "bin" if executables are in the bin folder)
+
+\tReturns:
+\t\tstr: The installation path for the program.
+\t'''
+def add_to_path(install_path: str, platform_str: str = ...) -> bool:
+    ''' Add the program to the PATH environment variable.
+
+\tArgs:
+\t\tinstall_path  (str):  The path to the program to add to the PATH environment variable.
+\t\tplatform_str  (str):  The platform you are running on (ex: "Windows", "Linux", "Darwin", ...),
+\t\t\twe use this to determine the installation path if not provided.
+
+\tReturns:
+\t\tbool: True if add to PATH was successful, False otherwise.
+\t'''
+def install_program(input_path: str, install_path: str = '', platform_str: str = ..., program_name: str = '', add_path: bool = True, append_to_path: str = '') -> bool:
+    ''' Install a program to a specific path from a local zip file or URL.
+
+\tArgs:
+\t\tinput_path     (str):  Path to a zip file or a download URL.
+\t\tinstall_path   (str):  The directory to extract the program into, we ask user for a path if not provided.
+\t\tplatform_str   (str):  The platform you are running on (ex: "Windows", "Linux", "Darwin", ...),
+\t\t\twe use this to determine the installation path if not provided.
+\t\tadd_path       (bool): Whether to add the program to the PATH environment variable.
+\t\tprogram_name   (str):  Override the program name, we get it from the input path if not provided.
+\t\tappend_to_path (str):  String to append to the installation path when adding to PATH.
+\t\t\t(ex: "bin" if executables are in the bin folder)
+
+\tReturns:
+\t\tbool: True if installation was successful, False otherwise.
+\t'''

stouputils/stouputils/installer/windows.pyi

@@ -0,0 +1,31 @@
+from ..decorators import LogLevels as LogLevels, handle_error as handle_error
+from ..io import clean_path as clean_path
+from ..print import debug as debug, info as info, warning as warning
+from .common import ask_install_type as ask_install_type, prompt_for_path as prompt_for_path
+
+def add_to_path_windows(install_path: str) -> bool | None:
+    """ Add install_path to the User PATH environment variable on Windows.
+
+\tArgs:
+\t\tinstall_path (str): The path to add to the User PATH environment variable.
+
+\tReturns:
+\t\tbool | None: True if the path was added to the User PATH environment variable, None otherwise.
+\t"""
+def check_admin_windows() -> bool:
+    """ Check if the script is running with administrator privileges on Windows. """
+def get_install_path_windows(program_name: str, ask_global: int = 0, add_path: bool = True, append_to_path: str = '', default_global: str = ...) -> str:
+    ''' Get the installation path for the program
+
+\tArgs:
+\t\tprogram_name  (str):   The name of the program to install.
+\t\task_global    (int):   0 = ask for anything, 1 = install globally, 2 = install locally
+\t\tadd_path      (bool):  Whether to add the program to the PATH environment variable. (Only if installed globally)
+\t\tappend_to_path (str):  String to append to the installation path when adding to PATH.
+\t\t\t(ex: "bin" if executables are in the bin folder)
+\t\tdefault_global (str):  The default global installation path.
+\t\t\t(Default is "C:\\Program Files" which is the most common location for executables on Windows)
+
+\tReturns:
+\t\tstr: The installation path.
+\t'''

stouputils/stouputils/io.pyi

@@ -0,0 +1,213 @@
+from typing import Any, IO
+
+def get_root_path(relative_path: str, go_up: int = 0) -> str:
+    """ Get the absolute path of the directory.
+\tUsually used to get the root path of the project using the __file__ variable.
+
+\tArgs:
+\t\trelative_path   (str): The path to get the absolute directory path from
+\t\tgo_up           (int): Number of parent directories to go up (default: 0)
+\tReturns:
+\t\tstr: The absolute path of the directory
+
+\tExamples:
+
+\t\t.. code-block:: python
+
+\t\t\t> get_root_path(__file__)
+\t\t\t'C:/Users/Alexandre-PC/AppData/Local/Programs/Python/Python310/lib/site-packages/stouputils'
+
+\t\t\t> get_root_path(__file__, 3)
+\t\t\t'C:/Users/Alexandre-PC/AppData/Local/Programs/Python/Python310'
+\t"""
+def relative_path(file_path: str, relative_to: str = '') -> str:
+    ''' Get the relative path of a file relative to a given directory.
+
+\tArgs:
+\t\tfile_path     (str): The path to get the relative path from
+\t\trelative_to   (str): The path to get the relative path to (default: current working directory -> os.getcwd())
+\tReturns:
+\t\tstr: The relative path of the file
+\tExamples:
+
+\t\t>>> relative_path("D:/some/random/path/stouputils/io.py", "D:\\\\some")
+\t\t\'random/path/stouputils/io.py\'
+\t\t>>> relative_path("D:/some/random/path/stouputils/io.py", "D:\\\\some\\\\")
+\t\t\'random/path/stouputils/io.py\'
+\t'''
+def json_dump(data: Any, file: IO[Any] | str | None = None, max_level: int | None = 2, indent: str | int = '\t', suffix: str = '\n', ensure_ascii: bool = False) -> str:
+    ''' Writes the provided data to a JSON file with a specified indentation depth.
+\tFor instance, setting max_level to 2 will limit the indentation to 2 levels.
+
+\tArgs:
+\t\tdata\t\t(Any): \t\t\t\tThe data to dump (usually a dict or a list)
+\t\tfile\t\t(IO[Any] | str): \tThe file object or path to dump the data to
+\t\tmax_level\t(int | None):\t\tThe depth of indentation to stop at (-1 for infinite), None will default to 2
+\t\tindent\t\t(str | int):\t\tThe indentation character (default: \'\\t\')
+\t\tsuffix\t\t(str):\t\t\t\tThe suffix to add at the end of the string (default: \'\\n\')
+\t\tensure_ascii (bool):\t\t\tWhether to escape non-ASCII characters (default: False)
+\tReturns:
+\t\tstr: The content of the file in every case
+
+\t>>> json_dump({"a": [[1,2,3]], "b": 2}, max_level = 0)
+\t\'{"a": [[1,2,3]],"b": 2}\\n\'
+\t>>> json_dump({"a": [[1,2,3]], "b": 2}, max_level = 1)
+\t\'{\\n\\t"a": [[1,2,3]],\\n\\t"b": 2\\n}\\n\'
+\t>>> json_dump({"a": [[1,2,3]], "b": 2}, max_level = 2)
+\t\'{\\n\\t"a": [\\n\\t\\t[1,2,3]\\n\\t],\\n\\t"b": 2\\n}\\n\'
+\t>>> json_dump({"a": [[1,2,3]], "b": 2}, max_level = 3)
+\t\'{\\n\\t"a": [\\n\\t\\t[\\n\\t\\t\\t1,\\n\\t\\t\\t2,\\n\\t\\t\\t3\\n\\t\\t]\\n\\t],\\n\\t"b": 2\\n}\\n\'
+\t>>> json_dump({"éà": "üñ"}, ensure_ascii = True, max_level = 0)
+\t\'{"\\\\u00e9\\\\u00e0": "\\\\u00fc\\\\u00f1"}\\n\'
+\t>>> json_dump({"éà": "üñ"}, ensure_ascii = False, max_level = 0)
+\t\'{"éà": "üñ"}\\n\'
+\t'''
+def json_load(file_path: str) -> Any:
+    """ Load a JSON file from the given path
+
+\tArgs:
+\t\tfile_path (str): The path to the JSON file
+\tReturns:
+\t\tAny: The content of the JSON file
+\t"""
+def csv_dump(data: Any, file: IO[Any] | str | None = None, delimiter: str = ',', has_header: bool = True, index: bool = False, *args: Any, **kwargs: Any) -> str:
+    ''' Writes data to a CSV file with customizable options and returns the CSV content as a string.
+
+\tArgs:
+\t\tdata\t\t(list[list[Any]] | list[dict[str, Any]] | pd.DataFrame | pl.DataFrame):
+\t\t\t\t\t\tThe data to write, either a list of lists, list of dicts, pandas DataFrame, or Polars DataFrame
+\t\tfile\t\t(IO[Any] | str): The file object or path to dump the data to
+\t\tdelimiter\t(str): The delimiter to use (default: \',\')
+\t\thas_header\t(bool): Whether to include headers (default: True, applies to dict and DataFrame data)
+\t\tindex\t\t(bool): Whether to include the index (default: False, only applies to pandas DataFrame)
+\t\t*args\t\t(Any): Additional positional arguments to pass to the underlying CSV writer or DataFrame method
+\t\t**kwargs\t(Any): Additional keyword arguments to pass to the underlying CSV writer or DataFrame method
+\tReturns:
+\t\tstr: The CSV content as a string
+
+\tExamples:
+
+\t\t>>> csv_dump([["a", "b", "c"], [1, 2, 3], [4, 5, 6]])
+\t\t\'a,b,c\\r\\n1,2,3\\r\\n4,5,6\\r\\n\'
+
+\t\t>>> csv_dump([{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}])
+\t\t\'name,age\\r\\nAlice,30\\r\\nBob,25\\r\\n\'
+\t'''
+def csv_load(file_path: str, delimiter: str = ',', has_header: bool = True, as_dict: bool = False, as_dataframe: bool = False, use_polars: bool = False, *args: Any, **kwargs: Any) -> Any:
+    ''' Load a CSV file from the given path
+
+\tArgs:
+\t\tfile_path (str): The path to the CSV file
+\t\tdelimiter (str): The delimiter used in the CSV (default: \',\')
+\t\thas_header (bool): Whether the CSV has a header row (default: True)
+\t\tas_dict (bool): Whether to return data as list of dicts (default: False)
+\t\tas_dataframe (bool): Whether to return data as a DataFrame (default: False)
+\t\tuse_polars (bool): Whether to use Polars instead of pandas for DataFrame (default: False, requires polars)
+\t\t*args: Additional positional arguments to pass to the underlying CSV reader or DataFrame method
+\t\t**kwargs: Additional keyword arguments to pass to the underlying CSV reader or DataFrame method
+\tReturns:
+\t\tlist[list[str]] | list[dict[str, str]] | pd.DataFrame | pl.DataFrame: The content of the CSV file
+
+\tExamples:
+
+\t\t.. code-block:: python
+
+\t\t\t> Assuming "test.csv" contains: a,b,c\\n1,2,3\\n4,5,6
+\t\t\t> csv_load("test.csv")
+\t\t\t[[\'1\', \'2\', \'3\'], [\'4\', \'5\', \'6\']]
+
+\t\t\t> csv_load("test.csv", as_dict=True)
+\t\t\t[{\'a\': \'1\', \'b\': \'2\', \'c\': \'3\'}, {\'a\': \'4\', \'b\': \'5\', \'c\': \'6\'}]
+
+\t\t\t> csv_load("test.csv", as_dataframe=True)
+\t\t\t   a  b  c
+\t\t\t0  1  2  3
+\t\t\t1  4  5  6
+
+\t\t.. code-block:: console
+
+\t\t\t> csv_load("test.csv", as_dataframe=True, use_polars=True)
+\t\t\tshape: (2, 3)
+\t\t\t┌─────┬─────┬─────┐
+\t\t\t│ a   ┆ b   ┆ c   │
+\t\t\t│ --- ┆ --- ┆ --- │
+\t\t\t│ i64 ┆ i64 ┆ i64 │
+\t\t\t╞═════╪═════╪═════╡
+\t\t\t│ 1   ┆ 2   ┆ 3   │
+\t\t\t│ 4   ┆ 5   ┆ 6   │
+\t\t\t└─────┴─────┴─────┘
+\t'''
+def super_copy(src: str, dst: str, create_dir: bool = True, symlink: bool = False) -> str:
+    """ Copy a file (or a folder) from the source to the destination
+
+\tArgs:
+\t\tsrc         (str):  The source path
+\t\tdst         (str):  The destination path
+\t\tcreate_dir  (bool): Whether to create the directory if it doesn't exist (default: True)
+\t\tsymlink     (bool): Whether to create a symlink instead of copying (Linux only, default: True)
+\tReturns:
+\t\tstr: The destination path
+\t"""
+def super_open(file_path: str, mode: str, encoding: str = 'utf-8') -> IO[Any]:
+    ''' Open a file with the given mode, creating the directory if it doesn\'t exist (only if writing)
+
+\tArgs:
+\t\tfile_path\t(str): The path to the file
+\t\tmode\t\t(str): The mode to open the file with, ex: "w", "r", "a", "wb", "rb", "ab"
+\t\tencoding\t(str): The encoding to use when opening the file (default: "utf-8")
+\tReturns:
+\t\topen: The file object, ready to be used
+\t'''
+def read_file(file_path: str, encoding: str = 'utf-8') -> str:
+    ''' Read the content of a file and return it as a string
+
+\tArgs:
+\t\tfile_path (str): The path to the file
+\t\tencoding  (str): The encoding to use when opening the file (default: "utf-8")
+\tReturns:
+\t\tstr: The content of the file
+\t'''
+def replace_tilde(path: str) -> str:
+    ''' Replace the "~" by the user\'s home directory
+
+\tArgs:
+\t\tpath (str): The path to replace the "~" by the user\'s home directory
+\tReturns:
+\t\tstr: The path with the "~" replaced by the user\'s home directory
+\tExamples:
+
+\t\t.. code-block:: python
+
+\t\t\t> replace_tilde("~/Documents/test.txt")
+\t\t\t\'/home/user/Documents/test.txt\'
+\t'''
+def clean_path(file_path: str, trailing_slash: bool = True) -> str:
+    ''' Clean the path by replacing backslashes with forward slashes and simplifying the path
+
+\tArgs:
+\t\tfile_path (str): The path to clean
+\t\ttrailing_slash (bool): Whether to keep the trailing slash, ex: "test/" -> "test/"
+\tReturns:
+\t\tstr: The cleaned path
+\tExamples:
+\t\t>>> clean_path("C:\\\\Users\\\\Stoupy\\\\Documents\\\\test.txt")
+\t\t\'C:/Users/Stoupy/Documents/test.txt\'
+
+\t\t>>> clean_path("Some Folder////")
+\t\t\'Some Folder/\'
+
+\t\t>>> clean_path("test/uwu/1/../../")
+\t\t\'test/\'
+
+\t\t>>> clean_path("some/./folder/../")
+\t\t\'some/\'
+
+\t\t>>> clean_path("folder1/folder2/../../folder3")
+\t\t\'folder3\'
+
+\t\t>>> clean_path("./test/./folder/")
+\t\t\'test/folder/\'
+
+\t\t>>> clean_path("C:/folder1\\\\folder2")
+\t\t\'C:/folder1/folder2\'
+\t'''