stouputils 1.9.5__tar.gz → 1.9.7__tar.gz

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

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

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

@@ -1,5 +1,6 @@
 """
-This module provides context managers for temporarily silencing output.
+This module provides context managers for various utilities such as logging to a file,
+measuring execution time, silencing output, and setting multiprocessing start methods.
 
 - LogToFile: Context manager to log to a file every print call (with LINE_UP handling)
 - MeasureTime: Context manager to measure execution time of a code block
@@ -18,14 +19,22 @@ import os
 import sys
 import time
 from collections.abc import Callable
-from typing import IO, Any, TextIO
+from contextlib import AbstractAsyncContextManager, AbstractContextManager
+from typing import IO, Any, TextIO, TypeVar
 
 from .io import super_open
 from .print import TeeMultiOutput, debug
 
+# Type variable for context managers
+T = TypeVar("T")
+
+# Abstract base class for context managers supporting both sync and async usage
+class AbstractBothContextManager(AbstractContextManager[T], AbstractAsyncContextManager[T]):
+    """ Abstract base class for context managers that support both synchronous and asynchronous usage. """
+    pass
 
 # Context manager to log to a file
-class LogToFile:
+class LogToFile(AbstractBothContextManager["LogToFile"]):
 	""" Context manager to log to a file.
 
 	This context manager allows you to temporarily log output to a file while still printing normally.
@@ -38,6 +47,8 @@ class LogToFile:
 		tee_stdout (bool): Whether to redirect stdout to the file (default: True)
 		tee_stderr (bool): Whether to redirect stderr to the file (default: True)
 		ignore_lineup (bool): Whether to ignore lines containing LINE_UP escape sequence in files (default: False)
+		restore_on_exit (bool): Whether to restore original stdout/stderr on exit (default: False)
+			This ctx uses TeeMultiOutput which handles closed files gracefully, so restoring is not mandatory.
 
 	Examples:
 		.. code-block:: python
@@ -46,6 +57,11 @@ class LogToFile:
 			> with stp.LogToFile("output.log"):
 			>     stp.info("This will be logged to output.log and printed normally")
 			>     print("This will also be logged")
+
+			> with stp.LogToFile("output.log") as log_ctx:
+			>     stp.warning("This will be logged to output.log and printed normally")
+			>     log_ctx.change_file("new_file.log")
+			>     print("This will be logged to new_file.log")
 	"""
 	def __init__(
 		self,
@@ -54,7 +70,8 @@ class LogToFile:
 		encoding: str = "utf-8",
 		tee_stdout: bool = True,
 		tee_stderr: bool = True,
-		ignore_lineup: bool = True
+		ignore_lineup: bool = True,
+		restore_on_exit: bool = False
 	) -> None:
 		self.path: str = path
 		""" Attribute remembering path to the log file """
@@ -68,19 +85,27 @@ class LogToFile:
 		""" Whether to redirect stderr to the file """
 		self.ignore_lineup: bool = ignore_lineup
 		""" Whether to ignore lines containing LINE_UP escape sequence in files """
-		self.file: IO[Any] = super_open(self.path, mode=self.mode, encoding=self.encoding)
+		self.restore_on_exit: bool = restore_on_exit
+		""" Whether to restore original stdout/stderr on exit.
+		This ctx uses TeeMultiOutput which handles closed files gracefully, so restoring is not mandatory. """
+		self.file: IO[Any]
 		""" Attribute remembering opened file """
-		self.original_stdout: TextIO = sys.stdout
+		self.original_stdout: TextIO
 		""" Original stdout before redirection """
-		self.original_stderr: TextIO = sys.stderr
+		self.original_stderr: TextIO
 		""" Original stderr before redirection """
 
 	def __enter__(self) -> LogToFile:
 		""" Enter context manager which opens the log file and redirects stdout/stderr """
+		# Open file
+		self.file = super_open(self.path, mode=self.mode, encoding=self.encoding)
+
 		# Redirect stdout and stderr if requested
 		if self.tee_stdout:
+			self.original_stdout = sys.stdout
 			sys.stdout = TeeMultiOutput(self.original_stdout, self.file, ignore_lineup=self.ignore_lineup)
 		if self.tee_stderr:
+			self.original_stderr = sys.stderr
 			sys.stderr = TeeMultiOutput(self.original_stderr, self.file, ignore_lineup=self.ignore_lineup)
 
 		# Return self
@@ -88,16 +113,35 @@ class LogToFile:
 
 	def __exit__(self, exc_type: type[BaseException]|None, exc_val: BaseException|None, exc_tb: Any|None) -> None:
 		""" Exit context manager which closes the log file and restores stdout/stderr """
-		# Restore original stdout and stderr
-		if self.tee_stdout:
-			sys.stdout = self.original_stdout
-
-		if self.tee_stderr:
-			sys.stderr = self.original_stderr
+		# Restore original stdout and stderr (if requested)
+		if self.restore_on_exit:
+			if self.tee_stdout:
+				sys.stdout = self.original_stdout
+			if self.tee_stderr:
+				sys.stderr = self.original_stderr
 
 		# Close file
 		self.file.close()
 
+	async def __aenter__(self) -> LogToFile:
+		""" Enter async context manager which opens the log file and redirects stdout/stderr """
+		return self.__enter__()
+
+	async def __aexit__(self, exc_type: type[BaseException]|None, exc_val: BaseException|None, exc_tb: Any|None) -> None:
+		""" Exit async context manager which closes the log file and restores stdout/stderr """
+		self.__exit__(exc_type, exc_val, exc_tb)
+
+	def change_file(self, new_path: str) -> None:
+		""" Change the log file to a new path.
+
+		Args:
+			new_path (str): New path to the log file
+		"""
+		# Close current file, open new file and redirect outputs
+		self.file.close()
+		self.path = new_path
+		self.__enter__()
+
 	@staticmethod
 	def common(logs_folder: str, filepath: str, func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
 		""" Common code used at the beginning of a program to launch main function
@@ -129,7 +173,7 @@ class LogToFile:
 			return func(*args, **kwargs)
 
 # Context manager to measure execution time
-class MeasureTime:
+class MeasureTime(AbstractBothContextManager["MeasureTime"]):
 	""" Context manager to measure execution time.
 
 	This context manager measures the execution time of the code block it wraps
@@ -202,9 +246,18 @@ class MeasureTime:
 					hours: int = hours % 24
 					self.print_func(f"{self.message}: {days}d {hours}h {minutes}m {seconds}s")
 
+	async def __aenter__(self) -> MeasureTime:
+		""" Enter async context manager, record start time """
+		return self.__enter__()
+
+	async def __aexit__(self, exc_type: type[BaseException]|None, exc_val: BaseException|None, exc_tb: Any|None) -> None:
+		""" Exit async context manager, calculate duration and print """
+		self.__exit__(exc_type, exc_val, exc_tb)
+
 # Context manager to temporarily silence output
-class Muffle:
+class Muffle(AbstractBothContextManager["Muffle"]):
 	""" Context manager that temporarily silences output.
+	(No thread-safety guaranteed)
 
 	Alternative to stouputils.decorators.silent()
 
@@ -215,18 +268,20 @@ class Muffle:
 	def __init__(self, mute_stderr: bool = False) -> None:
 		self.mute_stderr: bool = mute_stderr
 		""" Attribute remembering if stderr should be muted """
-		self.original_stdout: TextIO = sys.stdout
+		self.original_stdout: IO[Any]
 		""" Attribute remembering original stdout """
-		self.original_stderr: TextIO = sys.stderr
+		self.original_stderr: IO[Any]
 		""" Attribute remembering original stderr """
 
 	def __enter__(self) -> Muffle:
 		""" Enter context manager which redirects stdout and stderr to devnull """
 		# Redirect stdout to devnull
+		self.original_stdout = sys.stdout
 		sys.stdout = open(os.devnull, "w", encoding="utf-8")
 
 		# Redirect stderr to devnull if needed
 		if self.mute_stderr:
+			self.original_stderr = sys.stderr
 			sys.stderr = open(os.devnull, "w", encoding="utf-8")
 
 		# Return self
@@ -243,8 +298,16 @@ class Muffle:
 			sys.stderr.close()
 			sys.stderr = self.original_stderr
 
+	async def __aenter__(self) -> Muffle:
+		""" Enter async context manager which redirects stdout and stderr to devnull """
+		return self.__enter__()
+
+	async def __aexit__(self, exc_type: type[BaseException]|None, exc_val: BaseException|None, exc_tb: Any|None) -> None:
+		""" Exit async context manager which restores original stdout and stderr """
+		self.__exit__(exc_type, exc_val, exc_tb)
+
 # Context manager that does nothing
-class DoNothing:
+class DoNothing(AbstractBothContextManager["DoNothing"]):
 	""" Context manager that does nothing.
 
 	This is a no-op context manager that can be used as a placeholder
@@ -269,7 +332,7 @@ class DoNothing:
 		""" No initialization needed, this is a no-op context manager """
 		pass
 
-	def __enter__(self) -> Any:
+	def __enter__(self) -> DoNothing:
 		""" Enter context manager (does nothing) """
 		return self
 
@@ -277,16 +340,18 @@ class DoNothing:
 		""" Exit context manager (does nothing) """
 		pass
 
-	async def __aenter__(self) -> Any:
+	async def __aenter__(self) -> DoNothing:
 		""" Enter async context manager (does nothing) """
 		return self
 
 	async def __aexit__(self, *excinfo: Any) -> None:
 		""" Exit async context manager (does nothing) """
 		pass
+NullContextManager = DoNothing
+""" Alias for DoNothing context manager """
 
 # Context manager to temporarily set multiprocessing start method
-class SetMPStartMethod:
+class SetMPStartMethod(AbstractBothContextManager["SetMPStartMethod"]):
 	""" Context manager to temporarily set multiprocessing start method.
 
 	This context manager allows you to temporarily change the multiprocessing start method
@@ -333,3 +398,11 @@ class SetMPStartMethod:
 		if self.old_method != self.start_method:
 			mp.set_start_method(self.old_method, force=True)
 
+	async def __aenter__(self) -> SetMPStartMethod:
+		""" Enter async context manager which sets the start method """
+		return self.__enter__()
+
+	async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+		""" Exit async context manager which restores the original start method """
+		self.__exit__(exc_type, exc_val, exc_tb)
+

{stouputils-1.9.5 → stouputils-1.9.7}/stouputils/ctx.pyi

@@ -1,9 +1,16 @@
+import abc
 from .io import super_open as super_open
 from .print import TeeMultiOutput as TeeMultiOutput, debug as debug
 from collections.abc import Callable as Callable
-from typing import Any, IO, TextIO
+from contextlib import AbstractAsyncContextManager, AbstractContextManager
+from typing import Any, IO, TextIO, TypeVar
 
-class LogToFile:
+T = TypeVar('T')
+
+class AbstractBothContextManager(AbstractContextManager[T], AbstractAsyncContextManager[T], metaclass=abc.ABCMeta):
+    """ Abstract base class for context managers that support both synchronous and asynchronous usage. """
+
+class LogToFile(AbstractBothContextManager['LogToFile']):
     ''' Context manager to log to a file.
 
 \tThis context manager allows you to temporarily log output to a file while still printing normally.
@@ -16,6 +23,8 @@ class LogToFile:
 \t\ttee_stdout (bool): Whether to redirect stdout to the file (default: True)
 \t\ttee_stderr (bool): Whether to redirect stderr to the file (default: True)
 \t\tignore_lineup (bool): Whether to ignore lines containing LINE_UP escape sequence in files (default: False)
+\t\trestore_on_exit (bool): Whether to restore original stdout/stderr on exit (default: False)
+\t\t\tThis ctx uses TeeMultiOutput which handles closed files gracefully, so restoring is not mandatory.
 
 \tExamples:
 \t\t.. code-block:: python
@@ -24,6 +33,11 @@ class LogToFile:
 \t\t\t> with stp.LogToFile("output.log"):
 \t\t\t>     stp.info("This will be logged to output.log and printed normally")
 \t\t\t>     print("This will also be logged")
+
+\t\t\t> with stp.LogToFile("output.log") as log_ctx:
+\t\t\t>     stp.warning("This will be logged to output.log and printed normally")
+\t\t\t>     log_ctx.change_file("new_file.log")
+\t\t\t>     print("This will be logged to new_file.log")
 \t'''
     path: str
     mode: str
@@ -31,14 +45,25 @@ class LogToFile:
     tee_stdout: bool
     tee_stderr: bool
     ignore_lineup: bool
+    restore_on_exit: bool
     file: IO[Any]
     original_stdout: TextIO
     original_stderr: TextIO
-    def __init__(self, path: str, mode: str = 'w', encoding: str = 'utf-8', tee_stdout: bool = True, tee_stderr: bool = True, ignore_lineup: bool = True) -> None: ...
+    def __init__(self, path: str, mode: str = 'w', encoding: str = 'utf-8', tee_stdout: bool = True, tee_stderr: bool = True, ignore_lineup: bool = True, restore_on_exit: bool = False) -> None: ...
     def __enter__(self) -> LogToFile:
         """ Enter context manager which opens the log file and redirects stdout/stderr """
     def __exit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any | None) -> None:
         """ Exit context manager which closes the log file and restores stdout/stderr """
+    async def __aenter__(self) -> LogToFile:
+        """ Enter async context manager which opens the log file and redirects stdout/stderr """
+    async def __aexit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any | None) -> None:
+        """ Exit async context manager which closes the log file and restores stdout/stderr """
+    def change_file(self, new_path: str) -> None:
+        """ Change the log file to a new path.
+
+\t\tArgs:
+\t\t\tnew_path (str): New path to the log file
+\t\t"""
     @staticmethod
     def common(logs_folder: str, filepath: str, func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
         ''' Common code used at the beginning of a program to launch main function
@@ -57,7 +82,7 @@ class LogToFile:
 \t\t\t...     LogToFile.common(f"{ROOT}/logs", __file__, main)
 \t\t'''
 
-class MeasureTime:
+class MeasureTime(AbstractBothContextManager['MeasureTime']):
     ''' Context manager to measure execution time.
 
 \tThis context manager measures the execution time of the code block it wraps
@@ -91,9 +116,14 @@ class MeasureTime:
         """ Enter context manager, record start time """
     def __exit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any | None) -> None:
         """ Exit context manager, calculate duration and print """
+    async def __aenter__(self) -> MeasureTime:
+        """ Enter async context manager, record start time """
+    async def __aexit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any | None) -> None:
+        """ Exit async context manager, calculate duration and print """
 
-class Muffle:
+class Muffle(AbstractBothContextManager['Muffle']):
     ''' Context manager that temporarily silences output.
+\t(No thread-safety guaranteed)
 
 \tAlternative to stouputils.decorators.silent()
 
@@ -102,15 +132,19 @@ class Muffle:
 \t\t...     print("This will not be printed")
 \t'''
     mute_stderr: bool
-    original_stdout: TextIO
-    original_stderr: TextIO
+    original_stdout: IO[Any]
+    original_stderr: IO[Any]
     def __init__(self, mute_stderr: bool = False) -> None: ...
     def __enter__(self) -> Muffle:
         """ Enter context manager which redirects stdout and stderr to devnull """
     def __exit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any | None) -> None:
         """ Exit context manager which restores original stdout and stderr """
+    async def __aenter__(self) -> Muffle:
+        """ Enter async context manager which redirects stdout and stderr to devnull """
+    async def __aexit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: Any | None) -> None:
+        """ Exit async context manager which restores original stdout and stderr """
 
-class DoNothing:
+class DoNothing(AbstractBothContextManager['DoNothing']):
     ''' Context manager that does nothing.
 
 \tThis is a no-op context manager that can be used as a placeholder
@@ -133,16 +167,17 @@ class DoNothing:
 \t'''
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         """ No initialization needed, this is a no-op context manager """
-    def __enter__(self) -> Any:
+    def __enter__(self) -> DoNothing:
         """ Enter context manager (does nothing) """
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         """ Exit context manager (does nothing) """
-    async def __aenter__(self) -> Any:
+    async def __aenter__(self) -> DoNothing:
         """ Enter async context manager (does nothing) """
     async def __aexit__(self, *excinfo: Any) -> None:
         """ Exit async context manager (does nothing) """
+NullContextManager = DoNothing
 
-class SetMPStartMethod:
+class SetMPStartMethod(AbstractBothContextManager['SetMPStartMethod']):
     ''' Context manager to temporarily set multiprocessing start method.
 
 \tThis context manager allows you to temporarily change the multiprocessing start method
@@ -170,3 +205,7 @@ class SetMPStartMethod:
         """ Enter context manager which sets the start method """
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         """ Exit context manager which restores the original start method """
+    async def __aenter__(self) -> SetMPStartMethod:
+        """ Enter async context manager which sets the start method """
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """ Exit async context manager which restores the original start method """

{stouputils-1.9.5 → stouputils-1.9.7}/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,9 @@ 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.
+			If negative float between -1 and 0, it's treated as a percentage of len(args).
 		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 +111,13 @@ def multiprocessing(
 	# Handle parameters
 	if max_workers == -1:
 		max_workers = CPU_COUNT
+	if isinstance(max_workers, float):
+		if max_workers > 0:
+			assert max_workers <= 1, "max_workers as positive float must be between 0 and 1 (percentage of CPU_COUNT)"
+			max_workers = int(max_workers * CPU_COUNT)
+		else:
+			assert -1 <= max_workers < 0, "max_workers as negative float must be between -1 and 0 (percentage of len(args))"
+			max_workers = int(-max_workers * len(args))
 	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 +157,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 +176,9 @@ 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.
+			If negative float between -1 and 0, it's treated as a percentage of len(args).
 		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 +224,13 @@ def multithreading(
 	# Handle parameters
 	if max_workers == -1:
 		max_workers = CPU_COUNT
+	if isinstance(max_workers, float):
+		if max_workers > 0:
+			assert max_workers <= 1, "max_workers as positive float must be between 0 and 1 (percentage of CPU_COUNT)"
+			max_workers = int(max_workers * CPU_COUNT)
+		else:
+			assert -1 <= max_workers < 0, "max_workers as negative float must be between -1 and 0 (percentage of len(args))"
+			max_workers = int(-max_workers * len(args))
 	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.7}/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,9 @@ 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\t\tIf negative float between -1 and 0, it\'s treated as a percentage of len(args).
 \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 +66,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 +80,9 @@ 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\t\tIf negative float between -1 and 0, it\'s treated as a percentage of len(args).
 \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.