stouputils 1.1.1__tar.gz → 1.1.4__tar.gz

{stouputils-1.1.1 → stouputils-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stouputils
-Version: 1.1.1
+Version: 1.1.4
 Summary: Stouputils is a collection of utility modules designed to simplify and enhance the development process. It includes a range of tools for tasks such as execution of doctests, display utilities, decorators, as well as context managers, and many more.
 Project-URL: Homepage, https://github.com/Stoupy51/stouputils
 Project-URL: Issues, https://github.com/Stoupy51/stouputils/issues

{stouputils-1.1.1 → stouputils-1.1.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "stouputils"
-version = "1.1.1"
+version = "1.1.4"
 description = "Stouputils is a collection of utility modules designed to simplify and enhance the development process. It includes a range of tools for tasks such as execution of doctests, display utilities, decorators, as well as context managers, and many more."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,5 +32,5 @@ Issues = "https://github.com/Stoupy51/stouputils/issues"
 typeCheckingMode = "strict"
 
 [tool.hatch.build]
-include = ["src/**"]
+include = ["src"]
 

stouputils-1.1.1/src/stouputils/__init__.py

@@ -1,15 +0,0 @@
-
-# Imports
-from .print import *
-from .archive import *
-from .io import *
-from .decorators import *
-from .ctx import *
-from .parallel import *
-from .all_doctests import *
-from .collections import *
-from .backup import *
-
-# Folders
-from .continuous_delivery import *
-

stouputils-1.1.1/src/stouputils/all_doctests.py

@@ -1,98 +0,0 @@
-"""
-This module is used to run all the doctests for all the modules in a given directory.
-
-.. image:: https://raw.githubusercontent.com/Stoupy51/stouputils/refs/heads/main/assets/all_doctests_module.gif
-  :alt: stouputils all_doctests examples
-"""
-
-# Imports
-import os
-import sys
-from .print import info, error, progress
-from .decorators import measure_time, handle_error, LogLevels
-from . import decorators
-from doctest import TestResults, testmod
-from types import ModuleType
-import importlib
-import pkgutil
-
-def test_module_with_progress(module: ModuleType, separator: str) -> TestResults:
-	@measure_time(progress, message=f"Testing module '{module.__name__}' {separator}took")
-	def internal() -> TestResults:
-		return testmod(m=module)
-	return internal()
-
-# Main program
-def launch_tests(root_dir: str, importing_errors: LogLevels = LogLevels.WARNING_TRACEBACK, strict: bool = True) -> None:
-	""" Main function to launch tests for all modules in the given directory.
-
-	Args:
-		root_dir				(str):			Root directory to search for modules
-		importing_errors		(LogLevels):	Log level for the errors when importing modules
-		strict					(bool):			Modify the force_raise_exception variable to True in the decorators module
-	
-	Examples:
-		>>> launch_tests("unknown_dir")
-		Traceback (most recent call last):
-			...
-		ValueError: No modules found in 'unknown_dir'
-
-	.. code-block:: python
-
-		> launch_tests("/path/to/source")
-		[PROGRESS HH:MM:SS] Importing module 'module1'	took 0.001s
-		[PROGRESS HH:MM:SS] Importing module 'module2'	took 0.002s
-		[PROGRESS HH:MM:SS] Importing module 'module3'	took 0.003s
-		[PROGRESS HH:MM:SS] Importing module 'module4'	took 0.004s
-		[INFO HH:MM:SS] Testing 4 modules...
-		[PROGRESS HH:MM:SS] Testing module 'module1'	took 0.005s
-		[PROGRESS HH:MM:SS] Testing module 'module2'	took 0.006s
-		[PROGRESS HH:MM:SS] Testing module 'module3'	took 0.007s
-		[PROGRESS HH:MM:SS] Testing module 'module4'	took 0.008s
-	"""
-	if strict:
-		old_value: bool = strict
-		decorators.force_raise_exception = True
-		strict = old_value
-
-
-	# Get all modules from folder
-	sys.path.insert(0, root_dir)
-	modules_file_paths: list[str] = []
-	for directory_path, _, _ in os.walk(root_dir):
-		for module_info in pkgutil.walk_packages([directory_path]):
-			absolute_module_path: str = os.path.join(directory_path, module_info.name)
-			path: str = absolute_module_path.split(root_dir, 1)[1].replace(os.sep, ".")[1:]
-			if path not in modules_file_paths:
-				modules_file_paths.append(path)
-	if not modules_file_paths:
-		raise ValueError(f"No modules found in '{root_dir}'")
-
-	# Find longest module path for alignment
-	max_length: int = max(len(path) for path in modules_file_paths)
-
-	# Dynamically import all modules from iacob package recursively using pkgutil and importlib
-	modules: list[ModuleType] = []
-	separators: list[str] = []
-	for module_path in modules_file_paths:
-		separator: str = " " * (max_length - len(module_path))
-		@handle_error(error_log=importing_errors)
-		@measure_time(progress, message=f"Importing module '{module_path}' {separator}took")
-		def internal() -> None:
-			modules.append(importlib.import_module(module_path))
-			separators.append(separator)
-		internal()
-
-	# Run tests for each module
-	info(f"Testing {len(modules)} modules...")
-	separators = [s + " "*(len("Importing") - len("Testing")) for s in separators]
-	results: list[TestResults] = [test_module_with_progress(module, separator) for module, separator in zip(modules, separators)]
-
-	# Display any error lines for each module at the end of the script
-	for module, result in zip(modules, results):
-		if result.failed > 0:
-			error(f"Errors in module {module.__name__}", exit=False)
-
-	# Reset force_raise_exception back
-	decorators.force_raise_exception = strict
-

stouputils-1.1.1/src/stouputils/archive.py

@@ -1,119 +0,0 @@
-"""
-This module provides functions for creating and managing archives.
-
-- make_archive: Create a zip archive from a source directory with consistent file timestamps.
-- repair_zip_file: Try to repair a corrupted zip file by ignoring some of the errors
-
-.. image:: https://raw.githubusercontent.com/Stoupy51/stouputils/refs/heads/main/assets/archive_module.gif
-  :alt: stouputils archive examples
-"""
-
-# Imports
-import os
-from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED
-from .io import clean_path, super_copy
-from .decorators import handle_error, LogLevels
-from .dont_look.zip_file_override import ZipFileOverride
-
-# Function that makes an archive with consistency (same zip file each time)
-@handle_error()
-def make_archive(
-	source: str,
-	destinations: list[str]|str = [],
-	override_time: None | tuple[int, int, int, int, int, int] = None,
-	create_dir: bool = False
-) -> bool:
-	""" Create a zip archive from a source directory with consistent file timestamps.
-	(Meaning deterministic zip file each time)
-
-	Creates a zip archive from the source directory and copies it to one or more destinations.
-	The archive will have consistent file timestamps across runs if override_time is specified.
-	Uses maximum compression level (9) with ZIP_DEFLATED algorithm.
-
-	Args:
-		source				(str):						The source folder to archive
-		destinations		(list[str]|str):			The destination folder(s) or file(s) to copy the archive to
-		override_time		(None | tuple[int, ...]):	The constant time to use for the archive (e.g. (2024, 1, 1, 0, 0, 0) for 2024-01-01 00:00:00)
-		create_dir			(bool):						Whether to create the destination directory if it doesn't exist (default: False)
-	Returns:
-		bool: Always returns True unless any strong error
-	Examples:
-
-	.. code-block:: python
-
-		> make_archive("/path/to/source", "/path/to/destination.zip")
-		> make_archive("/path/to/source", ["/path/to/destination.zip", "/path/to/destination2.zip"])
-		> make_archive("src", "hello_from_year_2085.zip", override_time=(2085,1,1,0,0,0))
-	"""
-	# Fix copy_destinations type if needed
-	if destinations and isinstance(destinations, str):
-		destinations = [destinations]
-	if not destinations:
-		raise ValueError("destinations must be a list of at least one destination")
-
-	# Create the archive
-	destination: str = clean_path(destinations[0])
-	destination = destination if ".zip" in destination else destination + ".zip"
-	with ZipFile(destination, "w", compression=ZIP_DEFLATED, compresslevel=9) as zip:
-		for root, _, files in os.walk(source):
-			for file in files:
-				file_path: str = clean_path(os.path.join(root, file))
-				info: ZipInfo = ZipInfo(file_path)
-				info.compress_type = ZIP_DEFLATED
-				if override_time:
-					info.date_time = override_time
-				with open(file_path, "rb") as f:
-					zip.writestr(info, f.read())
-
-	# Copy the archive to the destination(s)
-	for dest_folder in destinations[1:]:
-		@handle_error(Exception, message=f"Unable to copy '{destination}' to '{dest_folder}'", error_log=LogLevels.WARNING)
-		def internal(src: str, dest: str) -> None:
-			super_copy(src, dest, create_dir=create_dir)
-		internal(destination, clean_path(dest_folder))
-
-	return True
-
-
-
-# Function that repair a corrupted zip file (ignoring some of the errors)
-@handle_error()
-def repair_zip_file(file_path: str, destination: str) -> bool:
-	""" Try to repair a corrupted zip file by ignoring some of the errors
-
-	Args:
-		file_path		(str):	Path of the zip file to repair
-		destination		(str):	Destination of the new file
-	Returns:
-		bool: Always returns True unless any strong error
-	
-	Examples:
-
-	.. code-block:: python
-
-		> repair_zip_file("/path/to/source.zip", "/path/to/destination.zip")
-	"""
-	# Check
-	if not os.path.exists(file_path):
-		raise FileNotFoundError(f"File '{file_path}' not found")
-	dirname: str = os.path.dirname(destination)
-	if dirname and not os.path.exists(dirname):
-		raise FileNotFoundError(f"Directory '{dirname}' not found")
-
-	# Read it
-	with ZipFileOverride(file_path, "r") as zip_file:
-
-		# Get a list of all the files in the ZIP file
-		file_list: list[str] = zip_file.namelist()
-
-		# Create a new ZIP file at the destination
-		with ZipFileOverride(destination, "w", compression=ZIP_DEFLATED) as new_zip_file:
-			for file_name in file_list:
-				try:
-					new_zip_file.writestr(file_name, zip_file.read(file_name))
-				except KeyboardInterrupt:
-					continue
-	
-	return True
-
-

stouputils-1.1.1/src/stouputils/backup.py

@@ -1,314 +0,0 @@
-"""
-This module provides utilities for backup management.
-
-- get_file_hash: Computes the SHA-256 hash of a file
-- create_delta_backup: Creates a ZIP delta backup, saving only modified or new files while tracking deleted files
-- consolidate_backups: Consolidates the files from the given backup and all previous ones into a new ZIP file
-- backup_cli: Main entry point for command line usage
-
-.. image:: https://raw.githubusercontent.com/Stoupy51/stouputils/refs/heads/main/assets/backup_module.gif
-  :alt: stouputils backup examples
-"""
-
-# Standard library imports
-import os
-import hashlib
-import zipfile
-import datetime
-import fnmatch
-
-# Local imports
-from .decorators import measure_time, handle_error
-from .print import info, warning, progress
-from .io import clean_path
-
-# Function to compute the SHA-256 hash of a file
-def get_file_hash(file_path: str) -> str | None:
-	""" Computes the SHA-256 hash of a file.
-
-	Args:
-		file_path (str): Path to the file
-	Returns:
-		str | None: SHA-256 hash as a hexadecimal string or None if an error occurs
-	"""
-	try:
-		sha256_hash = hashlib.sha256()
-		with open(file_path, "rb") as f:
-			for chunk in iter(lambda: f.read(4096), b""):
-				sha256_hash.update(chunk)
-		return sha256_hash.hexdigest()
-	except Exception as e:
-		warning(f"Error computing hash for file {file_path}: {e}")
-		return None
-
-# Function to extract the stored hash from a ZipInfo object's comment
-def extract_hash_from_zipinfo(zip_info: zipfile.ZipInfo) -> str | None:
-	""" Extracts the stored hash from a ZipInfo object's comment.
-
-	Args:
-		zip_info (zipfile.ZipInfo): The ZipInfo object representing a file in the ZIP
-	Returns:
-		str | None: The stored hash if available, otherwise None
-	"""
-	comment: bytes | None = zip_info.comment
-	comment_str: str | None = comment.decode() if comment else None
-	return comment_str if comment_str and len(comment_str) == 64 else None  # Ensure it's a valid SHA-256 hash
-
-# Function to retrieve all previous backups in a folder
-@measure_time(message="Retrieving previous backups")
-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.
-
-	Args:
-		backup_folder (str): The folder containing previous backup zip files
-		all_before (str | None): Path to the latest backup ZIP file (If endswith "/latest.zip" or "/", the latest backup will be used)
-	Returns:
-		dict[str, dict[str, str]]: Dictionary mapping backup file paths to dictionaries of {file_path: file_hash}
-	"""
-	backups: dict[str, dict[str, str]] = {}
-	list_dir: list[str] = sorted([clean_path(os.path.join(backup_folder, f)) for f in os.listdir(backup_folder)])
-
-	# If all_before is provided, don't include backups after it
-	if isinstance(all_before, str) and not (all_before.endswith("/latest.zip") or all_before.endswith("/") or os.path.isdir(all_before)):
-		list_dir = list_dir[:list_dir.index(all_before) + 1]
-
-	# Get all the backups
-	for filename in list_dir:
-		if filename.endswith(".zip"):
-			zip_path: str = clean_path(os.path.join(backup_folder, filename))
-			file_hashes: dict[str, str] = {}
-
-			try:
-				with zipfile.ZipFile(zip_path, "r") as zipf:
-					for inf in zipf.infolist():
-						if inf.filename != "__deleted_files__.txt":
-							stored_hash: str | None = extract_hash_from_zipinfo(inf)
-							if stored_hash is not None:  # Only store if hash exists
-								file_hashes[inf.filename] = stored_hash
-
-					backups[zip_path] = file_hashes
-			except Exception as e:
-				warning(f"Error reading backup {zip_path}: {e}")
-
-	return dict(reversed(backups.items()))
-
-# Function to check if a file exists in any previous backup
-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.
-
-	Args:
-		file_path (str): The relative path of the file
-		file_hash (str): The SHA-256 hash of the file
-		previous_backups (dict[str, dict[str, str]]): Dictionary mapping backup zip paths to their stored file hashes
-	Returns:
-		bool: True if the file exists unchanged in any previous backup, False otherwise
-	"""
-	for file_hashes in previous_backups.values():
-		if file_hashes.get(file_path) == file_hash:
-			return True
-	return False
-
-
-# Main backup function that creates a delta backup (only changed files)
-@measure_time(message="Creating ZIP backup")
-@handle_error()
-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.
-
-	Args:
-		source_path (str): Path to the source file or directory to back up
-		destination_folder (str): Path to the folder where the backup will be saved
-		exclude_patterns (list[str] | None): List of glob patterns to exclude from backup
-	Examples:
-
-	.. code-block:: python
-
-		> create_delta_backup("/path/to/source", "/path/to/backups", exclude_patterns=["libraries/*", "cache/*"])
-		[INFO HH:MM:SS] Creating ZIP backup
-		[INFO HH:MM:SS] Backup created: '/path/to/backups/backup_2025_02_18-10_00_00.zip'
-	"""
-	source_path = clean_path(os.path.abspath(source_path))
-	destination_folder = clean_path(os.path.abspath(destination_folder))
-
-	# Setup backup paths and create destination folder
-	base_name: str = os.path.basename(source_path.rstrip(os.sep)) or "backup"
-	backup_folder: str = clean_path(os.path.join(destination_folder, base_name))
-	os.makedirs(backup_folder, exist_ok=True)
-
-	# Get previous backups and track all files
-	previous_backups: dict[str, dict[str, str]] = get_all_previous_backups(backup_folder)
-	previous_files: set[str] = {file for backup in previous_backups.values() for file in backup}  # Collect all tracked files
-
-	# Create new backup filename with timestamp
-	timestamp: str = datetime.datetime.now().strftime("%Y_%m_%d-%H_%M_%S")
-	zip_filename: str = f"{timestamp}.zip"
-	destination_zip: str = clean_path(os.path.join(backup_folder, zip_filename))
-
-	# Create the ZIP file early to write files as we process them
-	with zipfile.ZipFile(destination_zip, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=9) as zipf:
-		deleted_files: set[str] = set()
-		has_changes: bool = False
-
-		# Process files one by one to avoid memory issues
-		if os.path.isdir(source_path):
-			for root, _, files in os.walk(source_path):
-				for file in files:
-					full_path: str = clean_path(os.path.join(root, file))
-					arcname: str = clean_path(os.path.relpath(full_path, start=os.path.dirname(source_path)))
-					
-					# Skip file if it matches any exclude pattern
-					if exclude_patterns and any(fnmatch.fnmatch(arcname, pattern) for pattern in exclude_patterns):
-						continue
-					
-					file_hash: str | None = get_file_hash(full_path)
-					if file_hash is None:
-						continue
-
-					# Check if file needs to be backed up
-					if not is_file_in_any_previous_backup(arcname, file_hash, previous_backups):
-						try:
-							zip_info: zipfile.ZipInfo = zipfile.ZipInfo(arcname)
-							zip_info.compress_type = zipfile.ZIP_DEFLATED
-							zip_info.comment = file_hash.encode()  # Store hash in comment
-							
-							# Read and write file in chunks
-							with open(full_path, "rb") as f:
-								with zipf.open(zip_info, "w", force_zip64=True) as zf:
-									for chunk in iter(lambda: f.read(4096), b""):
-										zf.write(chunk)
-							has_changes = True
-						except Exception as e:
-							warning(f"Error writing file {full_path} to backup: {e}")
-					
-					# Track current files for deletion detection
-					if arcname in previous_files:
-						previous_files.remove(arcname)
-		else:
-			arcname: str = clean_path(os.path.basename(source_path))
-			file_hash: str | None = get_file_hash(source_path)
-			
-			if file_hash is not None and not is_file_in_any_previous_backup(arcname, file_hash, previous_backups):
-				try:
-					zip_info: zipfile.ZipInfo = zipfile.ZipInfo(arcname)
-					zip_info.compress_type = zipfile.ZIP_DEFLATED
-					zip_info.comment = file_hash.encode()
-					
-					with open(source_path, "rb") as f:
-						with zipf.open(zip_info, "w", force_zip64=True) as zf:
-							for chunk in iter(lambda: f.read(4096), b""):
-								zf.write(chunk)
-					has_changes = True
-				except Exception as e:
-					warning(f"Error writing file {source_path} to backup: {e}")
-
-		# Any remaining files in previous_files were deleted
-		deleted_files = previous_files
-		if deleted_files:
-			zipf.writestr("__deleted_files__.txt", "\n".join(deleted_files), compress_type=zipfile.ZIP_DEFLATED)
-			has_changes = True
-
-	# Remove empty backup if no changes
-	if not has_changes:
-		os.remove(destination_zip)
-		info(f"No files to backup, skipping creation of backup '{destination_zip}'")
-	else:
-		info(f"Backup created: '{destination_zip}'")
-
-
-# Function to consolidate multiple backups into one comprehensive backup
-@measure_time(message="Consolidating backups")
-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,
-	ensuring that the most recent version of each file is kept and deleted files are not restored.
-
-	Args:
-		zip_path (str): Path to the latest backup ZIP file (If endswith "/latest.zip" or "/", the latest backup will be used)
-		destination_zip (str): Path to the destination ZIP file where the consolidated backup will be saved
-	Examples:
-
-	.. code-block:: python
-
-		> consolidate_backups("/path/to/backups/latest.zip", "/path/to/consolidated.zip")
-		[INFO HH:MM:SS] Consolidating backups
-		[INFO HH:MM:SS] Consolidated backup created: '/path/to/consolidated.zip'
-	"""
-	zip_path = clean_path(os.path.abspath(zip_path))
-	destination_zip = clean_path(os.path.abspath(destination_zip))
-	zip_folder: str = clean_path(os.path.dirname(zip_path))
-
-	# Get all previous backups up to the specified one
-	previous_backups: dict[str, dict[str, str]] = get_all_previous_backups(zip_folder, all_before=zip_path)
-
-	deleted_files: set[str] = set()
-	final_files: set[str] = set()
-
-	# Create destination ZIP file
-	with zipfile.ZipFile(destination_zip, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=9) as zipf_out:
-		# Process each backup, tracking deleted files and consolidating files
-		for backup_path in previous_backups:
-			with zipfile.ZipFile(backup_path, "r") as zipf_in:
-				# Process deleted files
-				if "__deleted_files__.txt" in zipf_in.namelist():
-					backup_deleted_files: list[str] = zipf_in.read("__deleted_files__.txt").decode().splitlines()
-					deleted_files.update(backup_deleted_files)
-
-				# Process files
-				for inf in zipf_in.infolist():
-					filename: str = inf.filename
-					if filename \
-						and filename != "__deleted_files__.txt" \
-						and filename not in final_files \
-						and filename not in deleted_files:
-						final_files.add(filename)
-						
-						# Copy file in chunks
-						with zipf_in.open(inf, "r") as source:
-							with zipf_out.open(inf, "w", force_zip64=True) as target:
-								for chunk in iter(lambda: source.read(4096), b""):
-									target.write(chunk)
-
-	info(f"Consolidated backup created: {destination_zip}")
-
-# Main entry point for command line usage
-@measure_time(progress)
-def backup_cli():
-	""" Main entry point for command line usage.
-
-	Examples:
-
-	.. code-block:: bash
-
-		# Create a delta backup, excluding libraries and cache folders
-		python -m stouputils.backup delta /path/to/source /path/to/backups -x "libraries/*" "cache/*"
-
-		# Consolidate backups into a single file
-		python -m stouputils.backup consolidate /path/to/backups/latest.zip /path/to/consolidated.zip
-	"""
-	import argparse
-
-	# Setup command line argument parser
-	parser: argparse.ArgumentParser = argparse.ArgumentParser(description="Backup and consolidate files using delta compression.")
-	subparsers = parser.add_subparsers(dest="command", required=True)
-
-	# Create delta command and its arguments
-	delta_parser = subparsers.add_parser("delta", help="Create a new delta backup")
-	delta_parser.add_argument("source", type=str, help="Path to the source directory or file")
-	delta_parser.add_argument("destination", type=str, help="Path to the destination folder for backups")
-	delta_parser.add_argument("-x", "--exclude", type=str, nargs="+", help="Glob patterns to exclude from backup", default=[])
-
-	# Create consolidate command and its arguments
-	consolidate_parser = subparsers.add_parser("consolidate", help="Consolidate existing backups into one")
-	consolidate_parser.add_argument("backup_zip", type=str, help="Path to the latest backup ZIP file")
-	consolidate_parser.add_argument("destination_zip", type=str, help="Path to the destination consolidated ZIP file")
-
-	# Parse arguments and execute appropriate command
-	args: argparse.Namespace = parser.parse_args()
-
-	if args.command == "delta":
-		create_delta_backup(args.source, args.destination, args.exclude)
-	elif args.command == "consolidate":
-		consolidate_backups(args.backup_zip, args.destination_zip)
-
-if __name__ == "__main__":
-	backup_cli()
-

stouputils-1.1.1/src/stouputils/collections.py

@@ -1,61 +0,0 @@
-"""
-This module provides utilities for collection manipulation:
-
-- unique_list: Remove duplicates from a list while preserving order using object id, hash or str
-
-.. image:: https://raw.githubusercontent.com/Stoupy51/stouputils/refs/heads/main/assets/collections_module.gif
-  :alt: stouputils collections examples
-"""
-
-# Imports
-from typing import Any, Literal
-
-# Functions
-def unique_list(list_to_clean: list[Any], method: Literal["id", "hash", "str"] = "str") -> list[Any]:
-	""" Remove duplicates from the list while keeping the order using ids (default) or hash or str
-
-	Args:
-		list_to_clean	(list[Any]):					The list to clean
-		method			(Literal["id", "hash", "str"]):	The method to use to identify duplicates
-	Returns:
-		list[Any]: The cleaned list
-	
-	Examples:
-		>>> unique_list([1, 2, 3, 2, 1], method="id")
-		[1, 2, 3]
-
-		>>> s1 = {1, 2, 3}
-		>>> s2 = {2, 3, 4}
-		>>> s3 = {1, 2, 3}
-		>>> unique_list([s1, s2, s1, s1, s3, s2, s3], method="id")
-		[{1, 2, 3}, {2, 3, 4}, {1, 2, 3}]
-
-		>>> s1 = {1, 2, 3}
-		>>> s2 = {2, 3, 4}
-		>>> s3 = {1, 2, 3}
-		>>> unique_list([s1, s2, s1, s1, s3, s2, s3], method="str")
-		[{1, 2, 3}, {2, 3, 4}]
-	"""
-	# Initialize the seen ids set and the result list
-	seen: set[Any] = set()
-	result: list[Any] = []
-
-	# Iterate over each item in the list
-	for item in list_to_clean:
-		if method == "id":
-			item_identifier = id(item)
-		elif method == "hash":
-			item_identifier = hash(item)
-		elif method == "str":
-			item_identifier = str(item)
-		else:
-			raise ValueError(f"Invalid method: {method}")
-
-		# If the item id is not in the seen ids set, add it to the seen ids set and append the item to the result list
-		if item_identifier not in seen:
-			seen.add(item_identifier)
-			result.append(item)
-
-	# Return the cleaned list
-	return result
-

stouputils-1.1.1/src/stouputils/continuous_delivery/__init__.py

@@ -1,7 +0,0 @@
-
-# Imports
-from .cd_utils import *
-from .github import *
-from .pypi import *
-from .pyproject import *
-