stouputils 1.9.5__tar.gz → 1.9.6__tar.gz

{stouputils-1.9.5 → stouputils-1.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stouputils
-Version: 1.9.5
+Version: 1.9.6
 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.9.5 → stouputils-1.9.6}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "stouputils"
-version = "1.9.5"
+version = "1.9.6"
 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.9.5 → stouputils-1.9.6}/stouputils/parallel.py

@@ -40,7 +40,7 @@ def multiprocessing(
 	use_starmap: bool = False,
 	chunksize: int = 1,
 	desc: str = "",
-	max_workers: int = CPU_COUNT,
+	max_workers: int | float = CPU_COUNT,
 	delay_first_calls: float = 0,
 	color: str = MAGENTA,
 	bar_format: str = BAR_FORMAT,
@@ -61,7 +61,8 @@ def multiprocessing(
 			(Defaults to 1 for proper progress bar display)
 		desc				(str):				Description displayed in the progress bar
 			(if not provided no progress bar will be displayed)
-		max_workers			(int):				Number of workers to use (Defaults to CPU_COUNT), -1 means CPU_COUNT
+		max_workers			(int | float):		Number of workers to use (Defaults to CPU_COUNT), -1 means CPU_COUNT.
+			If float between 0 and 1, it's treated as a percentage of 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.
@@ -109,6 +110,9 @@ def multiprocessing(
 	# Handle parameters
 	if max_workers == -1:
 		max_workers = CPU_COUNT
+	if isinstance(max_workers, float):
+		assert 0 < max_workers <= 1, "max_workers as float must be between 0 and 1 (percentage)"
+		max_workers = int(max_workers * CPU_COUNT)
 	verbose: bool = desc != ""
 	desc, func, args = _handle_parameters(func, args, use_starmap, delay_first_calls, max_workers, desc, color)
 	if bar_format == BAR_FORMAT:
@@ -148,7 +152,7 @@ def multithreading(
 	args: list[T],
 	use_starmap: bool = False,
 	desc: str = "",
-	max_workers: int = CPU_COUNT,
+	max_workers: int | float = CPU_COUNT,
 	delay_first_calls: float = 0,
 	color: str = MAGENTA,
 	bar_format: str = BAR_FORMAT,
@@ -167,7 +171,8 @@ def multithreading(
 			True means the function will be called like func(\*args[i]) instead of func(args[i])
 		desc				(str):				Description displayed in the progress bar
 			(if not provided no progress bar will be displayed)
-		max_workers			(int):				Number of workers to use (Defaults to CPU_COUNT), -1 means CPU_COUNT
+		max_workers			(int | float):		Number of workers to use (Defaults to CPU_COUNT), -1 means CPU_COUNT.
+			If float between 0 and 1, it's treated as a percentage of 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.
@@ -213,6 +218,9 @@ def multithreading(
 	# Handle parameters
 	if max_workers == -1:
 		max_workers = CPU_COUNT
+	if isinstance(max_workers, float):
+		assert 0 < max_workers <= 1, "max_workers as float must be between 0 and 1 (percentage)"
+		max_workers = int(max_workers * CPU_COUNT)
 	verbose: bool = desc != ""
 	desc, func, args = _handle_parameters(func, args, use_starmap, delay_first_calls, max_workers, desc, color)
 	if bar_format == BAR_FORMAT:

{stouputils-1.9.5 → stouputils-1.9.6}/stouputils/parallel.pyi

@@ -10,7 +10,7 @@ CPU_COUNT: int
 T = TypeVar('T')
 R = TypeVar('R')
 
-def multiprocessing(func: Callable[..., R] | list[Callable[..., R]], args: list[T], use_starmap: bool = False, chunksize: int = 1, desc: str = '', max_workers: int = ..., delay_first_calls: float = 0, color: str = ..., bar_format: str = ..., ascii: bool = False) -> list[R]:
+def multiprocessing(func: Callable[..., R] | list[Callable[..., R]], args: list[T], use_starmap: bool = False, chunksize: int = 1, desc: str = '', max_workers: int | float = ..., delay_first_calls: float = 0, color: str = ..., bar_format: str = ..., ascii: bool = False) -> list[R]:
     ''' Method to execute a function in parallel using multiprocessing
 
 \t- For CPU-bound operations where the GIL (Global Interpreter Lock) is a bottleneck.
@@ -26,7 +26,8 @@ def multiprocessing(func: Callable[..., R] | list[Callable[..., R]], args: list[
 \t\t\t(Defaults to 1 for proper progress bar display)
 \t\tdesc\t\t\t\t(str):\t\t\t\tDescription displayed in the progress bar
 \t\t\t(if not provided no progress bar will be displayed)
-\t\tmax_workers\t\t\t(int):\t\t\t\tNumber of workers to use (Defaults to CPU_COUNT), -1 means CPU_COUNT
+\t\tmax_workers\t\t\t(int | float):\t\tNumber of workers to use (Defaults to CPU_COUNT), -1 means CPU_COUNT.
+\t\t\tIf float between 0 and 1, it\'s treated as a percentage of CPU_COUNT.
 \t\tdelay_first_calls\t(float):\t\t\tApply i*delay_first_calls seconds delay to the first "max_workers" calls.
 \t\t\tFor instance, the first process will be delayed by 0 seconds, the second by 1 second, etc.
 \t\t\t(Defaults to 0): This can be useful to avoid functions being called in the same second.
@@ -64,7 +65,7 @@ def multiprocessing(func: Callable[..., R] | list[Callable[..., R]], args: list[
 \t\t\t. )
 \t\t\t[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 \t'''
-def multithreading(func: Callable[..., R] | list[Callable[..., R]], args: list[T], use_starmap: bool = False, desc: str = '', max_workers: int = ..., delay_first_calls: float = 0, color: str = ..., bar_format: str = ..., ascii: bool = False) -> list[R]:
+def multithreading(func: Callable[..., R] | list[Callable[..., R]], args: list[T], use_starmap: bool = False, desc: str = '', max_workers: int | float = ..., delay_first_calls: float = 0, color: str = ..., bar_format: str = ..., ascii: bool = False) -> list[R]:
     ''' Method to execute a function in parallel using multithreading, you should use it:
 
 \t- For I/O-bound operations where the GIL is not a bottleneck, such as network requests or disk operations.
@@ -78,7 +79,8 @@ def multithreading(func: Callable[..., R] | list[Callable[..., R]], args: list[T
 \t\t\tTrue means the function will be called like func(\\*args[i]) instead of func(args[i])
 \t\tdesc\t\t\t\t(str):\t\t\t\tDescription displayed in the progress bar
 \t\t\t(if not provided no progress bar will be displayed)
-\t\tmax_workers\t\t\t(int):\t\t\t\tNumber of workers to use (Defaults to CPU_COUNT), -1 means CPU_COUNT
+\t\tmax_workers\t\t\t(int | float):\t\tNumber of workers to use (Defaults to CPU_COUNT), -1 means CPU_COUNT.
+\t\t\tIf float between 0 and 1, it\'s treated as a percentage of CPU_COUNT.
 \t\tdelay_first_calls\t(float):\t\t\tApply i*delay_first_calls seconds delay to the first "max_workers" calls.
 \t\t\tFor instance with value to 1, the first thread will be delayed by 0 seconds, the second by 1 second, etc.
 \t\t\t(Defaults to 0): This can be useful to avoid functions being called in the same second.