stouputils 1.14.0__py3-none-any.whl

stouputils/stouputils/applications/upscaler/config.pyi

@@ -0,0 +1,18 @@
+WAIFU2X_NCNN_VULKAN_RELEASES: dict[str, str]
+FFMPEG_RELEASES: dict[str, str]
+YOUTUBE_BITRATE_RECOMMENDATIONS: dict[str, dict[str, dict[int, int]]]
+
+class Config:
+    """ Configuration class for the upscaler. """
+    JPG_QUALITY: int
+    VIDEO_FINAL_BITRATE: int
+    FFMPEG_EXECUTABLE: str
+    FFMPEG_ARGS: tuple[str, ...]
+    FFPROBE_EXECUTABLE: str
+    FFMPEG_CHECK_HELP_TEXT: str
+    UPSCALER_EXECUTABLE: str
+    UPSCALER_ARGS: tuple[str, ...]
+    UPSCALER_EXECUTABLE_HELP_TEXT: str
+    SLIGHTLY_FASTER_MODE: bool
+    upscaler_executable_checked: bool
+    ffmpeg_executable_checked: bool

stouputils/stouputils/applications/upscaler/image.pyi

@@ -0,0 +1,109 @@
+from ...installer import check_executable as check_executable
+from ...io import clean_path as clean_path
+from ...parallel import multithreading as multithreading
+from ...print import colored_for_loop as colored_for_loop, debug as debug, info as info
+from .config import Config as Config, WAIFU2X_NCNN_VULKAN_RELEASES as WAIFU2X_NCNN_VULKAN_RELEASES
+from tempfile import TemporaryDirectory
+
+def convert_frame(frame_path: str, delete_png: bool = True) -> None:
+    ''' Convert a PNG frame to JPG format to take less space.
+
+\tArgs:
+\t\tframe_path  (str):   Path to the PNG frame to convert.
+\t\tdelete_png  (bool):  Whether to delete the original PNG file after conversion.
+
+\tReturns:
+\t\tNone: This function doesn\'t return anything.
+
+\tExample:
+\t\t.. code-block:: python
+
+\t\t\t> convert_frame("input.png", delete_png=True)
+\t\t\t> # input.png will be converted to input.jpg and the original file will be deleted
+
+\t\t\t> convert_frame("input.png", delete_png=False)
+\t\t\t> # input.png will be converted to input.jpg and the original file will be kept
+\t'''
+def get_all_files(folder: str, suffix: str | tuple[str, ...] = '') -> list[str]:
+    ''' Get all files paths in a folder, with a specific suffix if provided.
+
+\tArgs:
+\t\tfolder     (str):                    Path to the folder containing the files.
+\t\tsuffix     (str | tuple[str, ...]):  Suffix of the files to get (e.g. ".png", ".jpg", etc.).
+
+\tReturns:
+\t\tlist[str]: List of all files paths in the folder.
+
+\tExample:
+\t\t>>> files: list[str] = get_all_files("some_folder", ".png")
+\t\t>>> len(files)
+\t\t0
+\t'''
+def create_temp_dir_for_not_upscaled(input_path: str, output_path: str) -> TemporaryDirectory[str] | None:
+    """ Creates a temporary directory containing only images that haven't been upscaled yet.
+
+    Args:
+        input_path  (str):  Path to the folder containing input images.
+        output_path (str):  Path to the folder where upscaled images are saved.
+
+    Returns:
+        TemporaryDirectory[str] | None: A temporary directory object if there are images to process,
+                                        None if all images are already upscaled.
+    """
+def check_upscaler_executable() -> None: ...
+def upscale(input_path: str, output_path: str, upscale_ratio: int) -> None:
+    ''' Upscale an input image (or a directory of images) with the upscaler executable.
+
+\tArgs:
+\t\tinput_path     (str):  Path to the image to upscale (or a directory).
+\t\toutput_path    (str):  Path to the output image (or a directory).
+\t\tupscale_ratio  (int):  Upscaling ratio.
+
+\tExample:
+\t\t.. code-block:: python
+
+\t\t\t> upscale("folder", "folder", 2)
+\t\t\tTraceback (most recent call last):
+\t\t\t\t...
+\t\t\tAssertionError: Input and output paths cannot be the same, got \'folder\'
+
+\t\t\t> upscale("stouputils", "stouputils/output.jpg", 2)
+\t\t\tTraceback (most recent call last):
+\t\t\t\t...
+\t\t\tAssertionError: If input is a directory, output must be a directory too, got \'stouputils/output.jpg\'
+
+
+\t\t\t> upscale("input.jpg", "output.jpg", 2)
+\t\t\t> # The input.jpg will be upscaled to output.jpg with a ratio of 2
+
+\t\t\t> upscale("input_folder", "output_folder", 2)
+\t\t\t> # The input_folder will be upscaled to output_folder with a ratio of 2
+\t'''
+def upscale_images(images: list[str], output_folder: str, upscale_ratio: int, desc: str = 'Upscaling images') -> None:
+    """ Upscale multiple images from a list.
+
+\tArgs:
+\t\timages        (list[str]): List of paths to the images to upscale.
+\t\toutput_folder (str):       Path to the output folder where the upscaled images will be saved.
+\t\tupscale_ratio (int):       Upscaling ratio.
+\t\tdesc          (str):       Description of the function execution displayed in the progress bar.
+\t\t\tNo progress bar will be displayed if desc is empty.
+
+\tReturns:
+\t\tNone: This function doesn't return anything.
+\t"""
+def upscale_folder(input_folder: str, output_folder: str, upscale_ratio: int, slightly_faster_mode: bool = True, desc: str = 'Upscaling folder') -> None:
+    """ Upscale all images in a folder.
+
+\tArgs:
+\t\tinput_folder          (str):   Path to the input folder containing the images to upscale.
+\t\toutput_folder         (str):   Path to the output folder where the upscaled images will be saved.
+\t\tupscale_ratio         (int):   Upscaling ratio.
+\t\tslightly_faster_mode  (bool):  Whether to use the slightly faster mode (no progress bar),
+\t\t\tone call to the upscaler executable.
+\t\tdesc                  (str):   Description of the function execution displayed in the progress bar.
+\t\t\tNo progress bar will be displayed if desc is empty.
+
+\tReturns:
+\t\tNone: This function doesn't return anything.
+\t"""

stouputils/stouputils/applications/upscaler/video.pyi

@@ -0,0 +1,60 @@
+from ...installer import check_executable as check_executable
+from ...io import clean_path as clean_path
+from ...parallel import multithreading as multithreading
+from ...print import colored_for_loop as colored_for_loop, debug as debug, error as error, info as info, warning as warning
+from .config import Config as Config, FFMPEG_RELEASES as FFMPEG_RELEASES, YOUTUBE_BITRATE_RECOMMENDATIONS as YOUTUBE_BITRATE_RECOMMENDATIONS
+from .image import convert_frame as convert_frame, get_all_files as get_all_files, upscale_folder as upscale_folder
+from typing import Literal
+
+def get_recommended_bitrate(resolution: tuple[int, int], frame_rate: int = 60, upload_type: Literal['SDR', 'HDR'] = 'SDR') -> int:
+    ''' Get the recommended bitrate (in kbps) for the output video based on the video resolution.
+
+\tArgs:
+\t\tresolution  (tuple[int, int]):       Video resolution (width, height).
+\t\tframe_rate  (int):                   Frame rate of the video, default is 60.
+\t\tupload_type (Literal["SDR","HDR"]):  Upload type from which the recommendation is made, default is "SDR".
+
+\tReturns:
+\t\tint:     The recommended bitrate for the output video (in kbps)
+
+\tSource: https://support.google.com/youtube/answer/1722171?hl=en#zippy=%2Cbitrate
+
+\tExamples:
+\t\t>>> # Valid examples
+\t\t>>> get_recommended_bitrate((3840, 2160), 60, "SDR")
+\t\t68000
+\t\t>>> get_recommended_bitrate((1920, 1080), 60, "HDR")
+\t\t15000
+\t\t>>> get_recommended_bitrate((1920, 1080), 60, "SDR")
+\t\t12000
+\t\t>>> get_recommended_bitrate((1920, 1080), 30, "SDR")
+\t\t8000
+
+\t\t>>> # Invalid examples
+\t\t>>> get_recommended_bitrate((1920, 1080), 60, "Ratio")
+\t\tTraceback (most recent call last):
+\t\t\t...
+\t\tAssertionError: Invalid upload type: \'Ratio\'
+\t\t>>> get_recommended_bitrate("1920x1080", 60, "SDR")
+\t\tTraceback (most recent call last):
+\t\t\t...
+\t\tAssertionError: Invalid resolution: 1920x1080, must be a tuple of two integers
+\t\t>>> get_recommended_bitrate((1920, 1080), -10, "SDR")
+\t\tTraceback (most recent call last):
+\t\t\t...
+\t\tAssertionError: Invalid frame rate: -10, must be a positive integer
+\t'''
+def check_ffmpeg_executable() -> None: ...
+def upscale_video(video_file: str, input_folder: str, progress_folder: str, output_folder: str) -> None:
+    """ Handles a video file. """
+def video_upscaler_cli(input_folder: str, progress_folder: str, output_folder: str) -> None:
+    """ Upscales videos from an input folder and saves them to an output folder.
+
+\tUses intermediate folders for extracted and upscaled frames within the progress folder.
+\t**Handles resuming partially processed videos.**
+
+\tArgs:
+\t\tinput_folder    (str): Path to the folder containing input videos.
+\t\tprogress_folder (str): Path to the folder for storing intermediate files (frames).
+\t\toutput_folder   (str): Path to the folder where upscaled videos will be saved.
+\t"""

stouputils/stouputils/archive.pyi

@@ -0,0 +1,67 @@
+from .decorators import LogLevels as LogLevels, handle_error as handle_error
+from .io import clean_path as clean_path, super_copy as super_copy
+from .print import CYAN as CYAN, GREEN as GREEN, RESET as RESET, debug as debug, error as error, info as info
+
+def repair_zip_file(file_path: str, destination: str) -> bool:
+    ''' Try to repair a corrupted zip file by ignoring some of the errors
+
+\tThis function manually parses the ZIP file structure to extract files
+\teven when the ZIP file is corrupted. It reads the central directory
+\tentries and attempts to decompress each file individually.
+
+\tArgs:
+\t\tfile_path\t\t(str):\tPath of the zip file to repair
+\t\tdestination\t\t(str):\tDestination of the new file
+\tReturns:
+\t\tbool: Always returns True unless any strong error
+
+\tExamples:
+
+\t.. code-block:: python
+
+\t\t> repair_zip_file("/path/to/source.zip", "/path/to/destination.zip")
+\t'''
+def make_archive(source: str, destinations: list[str] | str | None = None, override_time: None | tuple[int, int, int, int, int, int] = None, create_dir: bool = False, ignore_patterns: str | None = None) -> bool:
+    ''' Create a zip archive from a source directory with consistent file timestamps.
+\t(Meaning deterministic zip file each time)
+
+\tCreates a zip archive from the source directory and copies it to one or more destinations.
+\tThe archive will have consistent file timestamps across runs if override_time is specified.
+\tUses maximum compression level (9) with ZIP_DEFLATED algorithm.
+
+\tArgs:
+\t\tsource\t\t\t\t(str):\t\t\t\t\t\tThe source folder to archive
+\t\tdestinations\t\t(list[str]|str):\t\t\tThe destination folder(s) or file(s) to copy the archive to
+\t\toverride_time\t\t(None | tuple[int, ...]):\tThe constant time to use for the archive
+\t\t\t(e.g. (2024, 1, 1, 0, 0, 0) for 2024-01-01 00:00:00)
+\t\tcreate_dir\t\t\t(bool):\t\t\t\t\t\tWhether to create the destination directory if it doesn\'t exist
+\t\tignore_patterns\t\t(str | None):\t\t\t\tGlob pattern(s) to ignore files. Can be a single pattern or comma-separated patterns (e.g. "*.pyc" or "*.pyc,__pycache__,*.log")
+\tReturns:
+\t\tbool: Always returns True unless any strong error
+\tExamples:
+
+\t.. code-block:: python
+
+\t\t> make_archive("/path/to/source", "/path/to/destination.zip")
+\t\t> make_archive("/path/to/source", ["/path/to/destination.zip", "/path/to/destination2.zip"])
+\t\t> make_archive("src", "hello_from_year_2085.zip", override_time=(2085,1,1,0,0,0))
+\t\t> make_archive("src", "output.zip", ignore_patterns="*.pyc")
+\t\t> make_archive("src", "output.zip", ignore_patterns="__pycache__")
+\t\t> make_archive("src", "output.zip", ignore_patterns="*.pyc,__pycache__,*.log")
+\t'''
+def archive_cli() -> None:
+    ''' Main entry point for command line usage.
+
+\tExamples:
+
+\t.. code-block:: bash
+
+\t\t# Repair a corrupted zip file
+\t\tpython -m stouputils.archive repair /path/to/corrupted.zip /path/to/repaired.zip
+
+\t\t# Create a zip archive
+\t\tpython -m stouputils.archive make /path/to/source /path/to/destination.zip
+
+\t\t# Create a zip archive with ignore patterns
+\t\tpython -m stouputils.archive make /path/to/source /path/to/destination.zip --ignore "*.pyc,__pycache__"
+\t'''

stouputils/stouputils/backup.pyi

@@ -0,0 +1,109 @@
+import zipfile
+from .decorators import handle_error as handle_error, measure_time as measure_time
+from .io import clean_path as clean_path
+from .print import CYAN as CYAN, GREEN as GREEN, RESET as RESET, colored_for_loop as colored_for_loop, info as info, warning as warning
+
+CHUNK_SIZE: int
+LARGE_CHUNK_SIZE: int
+
+def backup_cli() -> None:
+    ''' Main entry point for command line usage.
+
+\tExamples:
+
+\t.. code-block:: bash
+
+\t\t# Create a delta backup, excluding libraries and cache folders
+\t\tpython -m stouputils.backup delta /path/to/source /path/to/backups -x "libraries/*" "cache/*"
+
+\t\t# Consolidate backups into a single file
+\t\tpython -m stouputils.backup consolidate /path/to/backups/latest.zip /path/to/consolidated.zip
+
+\t\t# Limit the number of delta backups to 5
+\t\tpython -m stouputils.backup limit 5 /path/to/backups
+\t'''
+def create_delta_backup(source_path: str, destination_folder: str, exclude_patterns: list[str] | None = None) -> None:
+    ''' Creates a ZIP delta backup, saving only modified or new files while tracking deleted files.
+
+\tArgs:
+\t\tsource_path (str): Path to the source file or directory to back up
+\t\tdestination_folder (str): Path to the folder where the backup will be saved
+\t\texclude_patterns (list[str] | None): List of glob patterns to exclude from backup
+\tExamples:
+
+\t.. code-block:: python
+
+\t\t> create_delta_backup("/path/to/source", "/path/to/backups", exclude_patterns=["libraries/*", "cache/*"])
+\t\t[INFO HH:MM:SS] Creating ZIP backup
+\t\t[INFO HH:MM:SS] Backup created: \'/path/to/backups/backup_2025_02_18-10_00_00.zip\'
+\t'''
+def consolidate_backups(zip_path: str, destination_zip: str) -> None:
+    ''' Consolidates the files from the given backup and all previous ones into a new ZIP file,
+\tensuring that the most recent version of each file is kept and deleted files are not restored.
+
+\tArgs:
+\t\tzip_path (str): Path to the latest backup ZIP file (If endswith "/latest.zip" or "/", the latest backup will be used)
+\t\tdestination_zip (str): Path to the destination ZIP file where the consolidated backup will be saved
+\tExamples:
+
+\t.. code-block:: python
+
+\t\t> consolidate_backups("/path/to/backups/latest.zip", "/path/to/consolidated.zip")
+\t\t[INFO HH:MM:SS] Consolidating backups
+\t\t[INFO HH:MM:SS] Consolidated backup created: \'/path/to/consolidated.zip\'
+\t'''
+def limit_backups(max_backups: int, backup_folder: str, keep_oldest: bool = True) -> None:
+    ''' Limits the number of delta backups by consolidating the oldest ones.
+
+\tIf the number of backups exceeds max_backups, the oldest backups are consolidated
+\tinto a single backup file, then deleted, until the count is within the limit.
+
+\tArgs:
+\t\tmax_backups (int): Maximum number of delta backups to keep
+\t\tbackup_folder (str): Path to the folder containing backups
+\t\tkeep_oldest (bool): If True, never delete the oldest backup (default: True)
+\tExamples:
+
+\t.. code-block:: python
+
+\t\t> limit_backups(5, "/path/to/backups")
+\t\t[INFO HH:MM:SS] Limiting backups
+\t\t[INFO HH:MM:SS] Consolidated 3 oldest backups into \'/path/to/backups/consolidated_YYYY_MM_DD-HH_MM_SS.zip\'
+\t\t[INFO HH:MM:SS] Deleted 3 old backups
+\t'''
+def get_file_hash(file_path: str) -> str | None:
+    """ Computes the SHA-256 hash of a file.
+
+\tArgs:
+\t\tfile_path (str): Path to the file
+\tReturns:
+\t\tstr | None: SHA-256 hash as a hexadecimal string or None if an error occurs
+\t"""
+def extract_hash_from_zipinfo(zip_info: zipfile.ZipInfo) -> str | None:
+    """ Extracts the stored hash from a ZipInfo object's comment.
+
+\tArgs:
+\t\tzip_info (zipfile.ZipInfo): The ZipInfo object representing a file in the ZIP
+\tReturns:
+\t\tstr | None: The stored hash if available, otherwise None
+\t"""
+def get_all_previous_backups(backup_folder: str, all_before: str | None = None) -> dict[str, dict[str, str]]:
+    ''' Retrieves all previous backups in a folder and maps each backup to a dictionary of file paths and their hashes.
+
+\tArgs:
+\t\tbackup_folder (str): The folder containing previous backup zip files
+\t\tall_before (str | None): Path to the latest backup ZIP file
+\t\t\t(If endswith "/latest.zip" or "/", the latest backup will be used)
+\tReturns:
+\t\tdict[str, dict[str, str]]: Dictionary mapping backup file paths to dictionaries of {file_path: file_hash}
+\t'''
+def is_file_in_any_previous_backup(file_path: str, file_hash: str, previous_backups: dict[str, dict[str, str]]) -> bool:
+    """ Checks if a file with the same hash exists in any previous backup.
+
+\tArgs:
+\t\tfile_path (str): The relative path of the file
+\t\tfile_hash (str): The SHA-256 hash of the file
+\t\tprevious_backups (dict[str, dict[str, str]]): Dictionary mapping backup zip paths to their stored file hashes
+\tReturns:
+\t\tbool: True if the file exists unchanged in any previous backup, False otherwise
+\t"""

stouputils/stouputils/collections.pyi

@@ -0,0 +1,86 @@
+import polars as pl
+import zarr
+from collections.abc import Iterable
+from numpy.typing import NDArray as NDArray
+from typing import Any, Literal, TypeVar
+
+T = TypeVar('T')
+
+def unique_list[T](list_to_clean: Iterable[T], method: Literal['id', 'hash', 'str'] = 'str') -> list[T]:
+    ''' Remove duplicates from the list while keeping the order using ids (default) or hash or str
+
+\tArgs:
+\t\tlist_to_clean\t(Iterable[T]):\t\t\t\t\tThe list to clean
+\t\tmethod\t\t\t(Literal["id", "hash", "str"]):\tThe method to use to identify duplicates
+\tReturns:
+\t\tlist[T]: The cleaned list
+
+\tExamples:
+\t\t>>> unique_list([1, 2, 3, 2, 1], method="id")
+\t\t[1, 2, 3]
+
+\t\t>>> s1 = {1, 2, 3}
+\t\t>>> s2 = {2, 3, 4}
+\t\t>>> s3 = {1, 2, 3}
+\t\t>>> unique_list([s1, s2, s1, s1, s3, s2, s3], method="id")
+\t\t[{1, 2, 3}, {2, 3, 4}, {1, 2, 3}]
+
+\t\t>>> s1 = {1, 2, 3}
+\t\t>>> s2 = {2, 3, 4}
+\t\t>>> s3 = {1, 2, 3}
+\t\t>>> unique_list([s1, s2, s1, s1, s3, s2, s3], method="str")
+\t\t[{1, 2, 3}, {2, 3, 4}]
+\t'''
+def sort_dict_keys[T](dictionary: dict[T, Any], order: list[T], reverse: bool = False) -> dict[T, Any]:
+    ''' Sort dictionary keys using a given order list (reverse optional)
+
+\tArgs:
+\t\tdictionary\t(dict[T, Any]):\tThe dictionary to sort
+\t\torder\t\t(list[T]):\t\tThe order list
+\t\treverse\t\t(bool):\t\t\tWhether to sort in reverse order (given to sorted function which behaves differently than order.reverse())
+\tReturns:
+\t\tdict[T, Any]: The sorted dictionary
+
+\tExamples:
+\t\t>>> sort_dict_keys({\'b\': 2, \'a\': 1, \'c\': 3}, order=["a", "b", "c"])
+\t\t{\'a\': 1, \'b\': 2, \'c\': 3}
+
+\t\t>>> sort_dict_keys({\'b\': 2, \'a\': 1, \'c\': 3}, order=["a", "b", "c"], reverse=True)
+\t\t{\'c\': 3, \'b\': 2, \'a\': 1}
+
+\t\t>>> sort_dict_keys({\'b\': 2, \'a\': 1, \'c\': 3, \'d\': 4}, order=["c", "b"])
+\t\t{\'c\': 3, \'b\': 2, \'a\': 1, \'d\': 4}
+\t'''
+def upsert_in_dataframe(df: pl.DataFrame, new_entry: dict[str, Any], primary_keys: dict[str, Any] | None = None) -> pl.DataFrame:
+    """ Insert or update a row in the Polars DataFrame based on primary keys.
+
+\tArgs:
+\t\tdf\t\t\t\t(pl.DataFrame):\t\tThe Polars DataFrame to update.
+\t\tnew_entry\t\t(dict[str, Any]):\tThe new entry to insert or update.
+\t\tprimary_keys\t(dict[str, Any]):\tThe primary keys to identify the row (default: empty).
+\tReturns:
+\t\tpl.DataFrame: The updated Polars DataFrame.
+\t"""
+def array_to_disk(data: NDArray[Any] | zarr.Array, delete_input: bool = True, more_data: NDArray[Any] | zarr.Array | None = None) -> tuple['zarr.Array', str, int]:
+    """ Easily handle large numpy arrays on disk using zarr for efficient storage and access.
+
+\tZarr provides a simpler and more efficient alternative to np.memmap with better compression
+\tand chunking capabilities.
+
+\tArgs:
+\t\tdata\t\t\t(NDArray | zarr.Array):\tThe data to save/load as a zarr array
+\t\tdelete_input\t(bool):\tWhether to delete the input data after creating the zarr array
+\t\tmore_data\t\t(NDArray | zarr.Array | None): Additional data to append to the zarr array
+\tReturns:
+\t\ttuple[zarr.Array, str, int]: The zarr array, the directory path, and the total size in bytes
+
+\tExamples:
+\t\t>>> import numpy as np
+\t\t>>> data = np.random.rand(1000, 1000)
+\t\t>>> zarr_array = array_to_disk(data)[0]
+\t\t>>> zarr_array.shape
+\t\t(1000, 1000)
+
+\t\t>>> more_data = np.random.rand(500, 1000)
+\t\t>>> longer_array, dir_path, total_size = array_to_disk(zarr_array, more_data=more_data)
+\t"""

stouputils/stouputils/continuous_delivery/__init__.pyi

@@ -0,0 +1,5 @@
+from .cd_utils import *
+from .github import *
+from .pypi import *
+from .pyproject import *
+from .stubs import *

stouputils/stouputils/continuous_delivery/cd_utils.pyi

@@ -0,0 +1,129 @@
+import requests
+from ..decorators import handle_error as handle_error
+from ..io import clean_path as clean_path, json_load as json_load
+from ..print import warning as warning
+from typing import Any
+
+def load_credentials(credentials_path: str) -> dict[str, Any]:
+    ''' Load credentials from a JSON or YAML file into a dictionary.
+
+\tLoads credentials from either a JSON or YAML file and returns them as a dictionary.
+\tThe file must contain the required credentials in the appropriate format.
+
+\tArgs:
+\t\tcredentials_path (str): Path to the credentials file (.json or .yml)
+\tReturns:
+\t\tdict[str, Any]: Dictionary containing the credentials
+
+\tExample JSON format:
+
+\t.. code-block:: json
+
+\t\t{
+\t\t\t"github": {
+\t\t\t\t"username": "Stoupy51",
+\t\t\t\t"api_key": "ghp_XXXXXXXXXXXXXXXXXXXXXXXXXX"
+\t\t\t}
+\t\t}
+
+\tExample YAML format:
+
+\t.. code-block:: yaml
+
+\t\tgithub:
+\t\t\tusername: "Stoupy51"
+\t\t\tapi_key: "ghp_XXXXXXXXXXXXXXXXXXXXXXXXXX"
+\t'''
+def handle_response(response: requests.Response, error_message: str) -> None:
+    """ Handle a response from the API by raising an error if the response is not successful (status code not in 200-299).
+
+\tArgs:
+\t\tresponse\t\t(requests.Response): The response from the API
+\t\terror_message\t(str): The error message to raise if the response is not successful
+\t"""
+def clean_version(version: str, keep: str = '') -> str:
+    ''' Clean a version string
+
+\tArgs:
+\t\tversion\t(str): The version string to clean
+\t\tkeep\t(str): The characters to keep in the version string
+\tReturns:
+\t\tstr: The cleaned version string
+
+\t>>> clean_version("v1.e0.zfezf0.1.2.3zefz")
+\t\'1.0.0.1.2.3\'
+\t>>> clean_version("v1.e0.zfezf0.1.2.3zefz", keep="v")
+\t\'v1.0.0.1.2.3\'
+\t>>> clean_version("v1.2.3b", keep="ab")
+\t\'1.2.3b\'
+\t'''
+def version_to_float(version: str, error: bool = True) -> Any:
+    ''' Converts a version string into a float for comparison purposes.
+\tThe version string is expected to follow the format of major.minor.patch.something_else....,
+\twhere each part is separated by a dot and can be extended indefinitely.
+\tSupports pre-release suffixes with numbers: devN/dN (dev), aN (alpha), bN (beta), rcN/cN (release candidate).
+\tOrdering: 1.0.0 > 1.0.0rc2 > 1.0.0rc1 > 1.0.0b2 > 1.0.0b1 > 1.0.0a2 > 1.0.0a1 > 1.0.0dev1
+
+\tArgs:
+\t\tversion (str): The version string to convert. (e.g. "v1.0.0.1.2.3", "v2.0.0b2", "v1.0.0rc1")
+\t\terror (bool): Return None on error instead of raising an exception
+\tReturns:
+\t\tfloat: The float representation of the version. (e.g. 0)
+
+\t>>> version_to_float("v1.0.0")
+\t1.0
+\t>>> version_to_float("v1.0.0.1")
+\t1.000000001
+\t>>> version_to_float("v2.3.7")
+\t2.003007
+\t>>> version_to_float("v1.0.0.1.2.3")
+\t1.0000000010020031
+\t>>> version_to_float("v2.0") > version_to_float("v1.0.0.1")
+\tTrue
+\t>>> version_to_float("v2.0.0") > version_to_float("v2.0.0rc") > version_to_float("v2.0.0b") > version_to_float("v2.0.0a") > version_to_float("v2.0.0dev")
+\tTrue
+\t>>> version_to_float("v1.0.0b") > version_to_float("v1.0.0a")
+\tTrue
+\t>>> version_to_float("v1.0.0") > version_to_float("v1.0.0b")
+\tTrue
+\t>>> version_to_float("v3.0.0a") > version_to_float("v2.9.9")
+\tTrue
+\t>>> version_to_float("v1.2.3b") < version_to_float("v1.2.3")
+\tTrue
+\t>>> version_to_float("1.0.0") == version_to_float("v1.0.0")
+\tTrue
+\t>>> version_to_float("2.0.0.0.0.0.1b") > version_to_float("2.0.0.0.0.0.1a")
+\tTrue
+\t>>> version_to_float("2.0.0.0.0.0.1") > version_to_float("2.0.0.0.0.0.1b")
+\tTrue
+\t>>> version_to_float("v1.0.0rc") == version_to_float("v1.0.0c")
+\tTrue
+\t>>> version_to_float("v1.0.0c") > version_to_float("v1.0.0b")
+\tTrue
+\t>>> version_to_float("v1.0.0d") < version_to_float("v1.0.0a")
+\tTrue
+\t>>> version_to_float("v1.0.0dev") < version_to_float("v1.0.0a")
+\tTrue
+\t>>> version_to_float("v1.0.0dev") == version_to_float("v1.0.0d")
+\tTrue
+\t>>> version_to_float("v1.0.0rc2") > version_to_float("v1.0.0rc1")
+\tTrue
+\t>>> version_to_float("v1.0.0b2") > version_to_float("v1.0.0b1")
+\tTrue
+\t>>> version_to_float("v1.0.0a2") > version_to_float("v1.0.0a1")
+\tTrue
+\t>>> version_to_float("v1.0.0dev2") > version_to_float("v1.0.0dev1")
+\tTrue
+\t>>> version_to_float("v1.0.0") > version_to_float("v1.0.0rc2") > version_to_float("v1.0.0rc1")
+\tTrue
+\t>>> version_to_float("v1.0.0rc1") > version_to_float("v1.0.0b2")
+\tTrue
+\t>>> version_to_float("v1.0.0b1") > version_to_float("v1.0.0a2")
+\tTrue
+\t>>> version_to_float("v1.0.0a1") > version_to_float("v1.0.0dev2")
+\tTrue
+\t>>> versions = ["v1.0.0", "v1.0.0rc2", "v1.0.0rc1", "v1.0.0b2", "v1.0.0b1", "v1.0.0a2", "v1.0.0a1", "v1.0.0dev2", "v1.0.0dev1"]
+\t>>> sorted_versions = sorted(versions, key=version_to_float, reverse=True)
+\t>>> sorted_versions == versions
+\tTrue
+\t'''