PyPI - stouputils - Versions diffs - 1.2.27__tar.gz → 1.2.29__tar.gz - Mend

stouputils 1.2.27tar.gz → 1.2.29tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

{stouputils-1.2.27 → stouputils-1.2.29}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stouputils
-Version: 1.2.27
+Version: 1.2.29
 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
@@ -38,7 +38,7 @@ It includes a range of tools for tasks such as execution of doctests, display ut
 # 🚀 Project File Tree
+<html>
 <style>
 .code-tree {
 	border-radius: 6px;
@@ -86,6 +86,7 @@ It includes a range of tools for tasks such as execution of doctests, display ut
 ├── <a href="https://stoupy51.github.io/stouputils/latest/modules/stouputils.print.html">print.py</a>                 <span class="comment"># 🖨️ Display utilities (info, debug, warning, error)</span>
 └── ...
 </pre>
+</html>
 ## ⭐ Star History

{stouputils-1.2.27 → stouputils-1.2.29}/README.md RENAMED Viewed

@@ -11,7 +11,7 @@ It includes a range of tools for tasks such as execution of doctests, display ut
 # 🚀 Project File Tree
+<html>
 <style>
 .code-tree {
 	border-radius: 6px;
@@ -59,6 +59,7 @@ It includes a range of tools for tasks such as execution of doctests, display ut
 ├── <a href="https://stoupy51.github.io/stouputils/latest/modules/stouputils.print.html">print.py</a>                 <span class="comment"># 🖨️ Display utilities (info, debug, warning, error)</span>
 └── ...
 </pre>
+</html>
 ## ⭐ Star History

{stouputils-1.2.27 → stouputils-1.2.29}/pyproject.toml RENAMED Viewed

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "stouputils"
-version = "1.2.27"
+version = "1.2.29"
 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"

{stouputils-1.2.27 → stouputils-1.2.29}/stouputils/decorators.py RENAMED Viewed

@@ -25,6 +25,11 @@ from typing import Callable, Literal, Any
 from functools import wraps
 from .print import debug, warning, error
+def get_func_name(func: Callable[..., Any]) -> str:
+	try:
+		return func.__name__
+	except:
+		return "<unknown>"
 # Decorator that make a function silent (disable stdout)
 def silent(
@@ -113,7 +118,7 @@ def measure_time(
 		# Set the message if not specified
 		nonlocal message
 		if not message:
-			message = f"Execution time of {func.__name__}"
+			message = f"Execution time of {get_func_name(func)}"
 		@wraps(func)
 		def wrapper(*args: tuple[Any, ...], **kwargs: dict[str, Any]) -> Any:
@@ -213,11 +218,11 @@ def handle_error(
 				return func(*args, **kwargs)
 			except exceptions as e:
 				if error_log == LogLevels.WARNING:
-					warning(f"{msg}Error during {func.__name__}: ({type(e).__name__}) {e}")
+					warning(f"{msg}Error during {get_func_name(func)}: ({type(e).__name__}) {e}")
 				elif error_log == LogLevels.WARNING_TRACEBACK:
-					warning(f"{msg}Error during {func.__name__}:\n{format_exc()}")
+					warning(f"{msg}Error during {get_func_name(func)}:\n{format_exc()}")
 				elif error_log == LogLevels.ERROR_TRACEBACK:
-					error(f"{msg}Error during {func.__name__}:\n{format_exc()}", exit=True)
+					error(f"{msg}Error during {get_func_name(func)}:\n{format_exc()}", exit=True)
 				elif error_log == LogLevels.RAISE_EXCEPTION:
 					raise e
 		return wrapper
@@ -327,7 +332,7 @@ def deprecated(
 		@wraps(func)
 		def wrapper(*args: tuple[Any, ...], **kwargs: dict[str, Any]) -> Any:
 			# Build deprecation message
-			msg: str = f"Function '{func.__name__}()' is deprecated"
+			msg: str = f"Function '{get_func_name(func)}()' is deprecated"
 			if message:
 				msg += f". {message}"
@@ -385,7 +390,7 @@ def abstract(
 		NotImplementedError: Function 'method' is abstract and must be implemented by a subclass
 	"""
 	def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
-		message: str = f"Function '{func.__name__}' is abstract and must be implemented by a subclass"
+		message: str = f"Function '{get_func_name(func)}' is abstract and must be implemented by a subclass"
 		if not func.__doc__:
 			func.__doc__ = message

{stouputils-1.2.27 → stouputils-1.2.29}/stouputils/parallel.py RENAMED Viewed

@@ -12,7 +12,7 @@ I highly encourage you to read the function docstrings to understand when to use
 # Imports
 from .print import MAGENTA, RESET
-from .decorators import handle_error, LogLevels
+from .decorators import handle_error, LogLevels, get_func_name
 from multiprocessing import Pool, cpu_count
 from typing import Callable, TypeVar
 from tqdm.auto import tqdm
@@ -50,7 +50,8 @@ def __handle_parameters(
 	use_starmap: bool,
 	delay_first_calls: float,
 	max_workers: int,
-	desc: str
+	desc: str,
+	color: str
 ) -> tuple[str, Callable[[T], R], list[T]]:
 	r""" Private function to handle the parameters for multiprocessing or multithreading functions
@@ -61,12 +62,13 @@ def __handle_parameters(
 		delay_first_calls	(int):				Apply i*delay_first_calls seconds delay to the first "max_workers" calls. For instance, the first process will be delayed by 0 seconds, the second by 1 second, etc. (Defaults to 0): This can be useful to avoid functions being called in the same second.
 		max_workers			(int):				Number of workers to use (Defaults to CPU_COUNT)
 		desc				(str):				Description of the function execution displayed in the progress bar
+		color				(str):				Color of the progress bar
 	Returns:
 		tuple[str, Callable[[T], R], list[T]]:	Tuple containing the description, function, and arguments
 	"""
 	if not desc:
-		desc = func.__name__
-	desc = MAGENTA + desc
+		desc = get_func_name(func)
+	desc = color + desc
 	# If use_starmap is True, we use the __starmap function
 	if use_starmap:
@@ -84,7 +86,19 @@ def __handle_parameters(
 	return desc, func, args
 @handle_error(error_log=LogLevels.ERROR_TRACEBACK)
-def multiprocessing(func: Callable[[T], R], args: list[T], use_starmap: bool = False, chunksize: int = 1, desc: str = "", max_workers: int = CPU_COUNT, delay_first_calls: float = 0, verbose: int = 0) -> list[R]:
+def multiprocessing(
+	func: Callable[[T], R],
+	args: list[T],
+	use_starmap: bool = False,
+	chunksize: int = 1,
+	desc: str = "",
+	max_workers: int = CPU_COUNT,
+	delay_first_calls: float = 0,
+	color: str = MAGENTA,
+	bar_format: str = BAR_FORMAT,
+	ascii: bool = False,
+	verbose: int = 0
+) -> list[R]:
 	r""" Method to execute a function in parallel using multiprocessing, you should use it:
 	- For CPU-bound operations where the GIL (Global Interpreter Lock) is a bottleneck.
@@ -98,8 +112,13 @@ def multiprocessing(func: Callable[[T], R], args: list[T], use_starmap: bool = F
 		chunksize			(int):				Number of arguments to process at a time (Defaults to 1 for proper progress bar display)
 		desc				(str):				Description of the function execution displayed in the progress bar
 		max_workers			(int):				Number of workers to use (Defaults to CPU_COUNT)
-		delay_first_calls	(float):			Apply i*delay_first_calls seconds delay to the first "max_workers" calls. For instance, the first process will be delayed by 0 seconds, the second by 1 second, etc. (Defaults to 0): This can be useful to avoid functions being called in the same second.
-		verbose				(int):				Level of verbosity, decrease by 1 for each depth
+		delay_first_calls	(float):			Apply i*delay_first_calls seconds delay to the first "max_workers" calls.
+			For instance, the first process will be delayed by 0 seconds, the second by 1 second, etc.
+			(Defaults to 0): This can be useful to avoid functions being called in the same second.
+		color				(str):				Color of the progress bar (Defaults to MAGENTA)
+		bar_format			(str):				Format of the progress bar (Defaults to BAR_FORMAT)
+		ascii				(bool):				Whether to use ASCII or Unicode characters for the progress bar (Defaults to False)
+		verbose				(int):				Level of verbosity, decrease by 1 for each depth (Defaults to 0)
 	Returns:
 		list[object]:	Results of the function execution
 	Examples:
@@ -118,12 +137,14 @@ def multiprocessing(func: Callable[[T], R], args: list[T], use_starmap: bool = F
 		[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 	"""
 	# Handle parameters
-	desc, func, args = __handle_parameters(func, args, use_starmap, delay_first_calls, max_workers, desc)
+	desc, func, args = __handle_parameters(func, args, use_starmap, delay_first_calls, max_workers, desc, color)
+	if bar_format == BAR_FORMAT:
+		bar_format = bar_format.replace(MAGENTA, color)
 	# Do multiprocessing only if there is more than 1 argument and more than 1 CPU
 	if max_workers > 1 and len(args) > 1:
 		if verbose > 0:
-			return list(process_map(func, args, max_workers=max_workers, chunksize=chunksize, desc=desc, bar_format=BAR_FORMAT, ascii=False)) # type: ignore
+			return list(process_map(func, args, max_workers=max_workers, chunksize=chunksize, desc=desc, bar_format=bar_format, ascii=ascii)) # type: ignore
 		else:
 			with Pool(max_workers) as pool:
 				return list(pool.map(func, args, chunksize=chunksize))	# type: ignore
@@ -131,13 +152,24 @@ def multiprocessing(func: Callable[[T], R], args: list[T], use_starmap: bool = F
 	# Single process execution
 	else:
 		if verbose > 0:
-			return [func(arg) for arg in tqdm(args, total=len(args), desc=desc, bar_format=BAR_FORMAT, ascii=False)]
+			return [func(arg) for arg in tqdm(args, total=len(args), desc=desc, bar_format=bar_format, ascii=ascii)]
 		else:
 			return [func(arg) for arg in args]
 @handle_error(error_log=LogLevels.ERROR_TRACEBACK)
-def multithreading(func: Callable[[T], R], args: list[T], use_starmap: bool = False, desc: str = "", max_workers: int = CPU_COUNT, delay_first_calls: float = 0, verbose: int = 0) -> list[R]:
+def multithreading(
+	func: Callable[[T], R],
+	args: list[T],
+	use_starmap: bool = False,
+	desc: str = "",
+	max_workers: int = CPU_COUNT,
+	delay_first_calls: float = 0,
+	color: str = MAGENTA,
+	bar_format: str = BAR_FORMAT,
+	ascii: bool = False,
+	verbose: int = 0
+	) -> list[R]:
 	r""" Method to execute a function in parallel using multithreading, you should use it:
 	- For I/O-bound operations where the GIL is not a bottleneck, such as network requests or disk operations.
@@ -150,8 +182,13 @@ def multithreading(func: Callable[[T], R], args: list[T], use_starmap: bool = Fa
 		use_starmap			(bool):				Whether to use starmap or not (Defaults to False): True means the function will be called like func(\*args[i]) instead of func(args[i])
 		desc				(str):				Description of the function execution displayed in the progress bar
 		max_workers			(int):				Number of workers to use (Defaults to CPU_COUNT)
-		delay_first_calls	(float):			Apply i*delay_first_calls seconds delay to the first "max_workers" calls. For instance with value to 1, the first thread will be delayed by 0 seconds, the second by 1 second, etc. (Defaults to 0): This can be useful to avoid functions being called in the same second.
-		verbose				(int):				Level of verbosity, decrease by 1 for each depth
+		delay_first_calls	(float):			Apply i*delay_first_calls seconds delay to the first "max_workers" calls.
+			For instance with value to 1, the first thread will be delayed by 0 seconds, the second by 1 second, etc.
+			(Defaults to 0): This can be useful to avoid functions being called in the same second.
+		color				(str):				Color of the progress bar (Defaults to MAGENTA)
+		bar_format			(str):				Format of the progress bar (Defaults to BAR_FORMAT)
+		ascii				(bool):				Whether to use ASCII or Unicode characters for the progress bar (Defaults to False)
+		verbose				(int):				Level of verbosity, decrease by 1 for each depth (Defaults to 0)
 	Returns:
 		list[object]:	Results of the function execution
 	Examples:
@@ -170,13 +207,15 @@ def multithreading(func: Callable[[T], R], args: list[T], use_starmap: bool = Fa
 		[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 	"""
 	# Handle parameters
-	desc, func, args = __handle_parameters(func, args, use_starmap, delay_first_calls, max_workers, desc)
+	desc, func, args = __handle_parameters(func, args, use_starmap, delay_first_calls, max_workers, desc, color)
+	if bar_format == BAR_FORMAT:
+		bar_format = bar_format.replace(MAGENTA, color)
 	# Do multithreading only if there is more than 1 argument and more than 1 CPU
 	if max_workers > 1 and len(args) > 1:
 		if verbose > 0:
 			with ThreadPoolExecutor(max_workers) as executor:
-				return list(tqdm(executor.map(func, args), total=len(args), desc=desc, bar_format=BAR_FORMAT, ascii=False))
+				return list(tqdm(executor.map(func, args), total=len(args), desc=desc, bar_format=bar_format, ascii=ascii))
 		else:
 			with ThreadPoolExecutor(max_workers) as executor:
 				return list(executor.map(func, args))
@@ -184,7 +223,7 @@ def multithreading(func: Callable[[T], R], args: list[T], use_starmap: bool = Fa
 	# Single process execution
 	else:
 		if verbose > 0:
-			return [func(arg) for arg in tqdm(args, total=len(args), desc=desc, bar_format=BAR_FORMAT, ascii=False)]
+			return [func(arg) for arg in tqdm(args, total=len(args), desc=desc, bar_format=bar_format, ascii=ascii)]
 		else:
 			return [func(arg) for arg in args]