stouputils 1.9.1__tar.gz → 1.9.2__tar.gz

{stouputils-1.9.1 → stouputils-1.9.2}/PKG-INFO

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

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

@@ -17,7 +17,6 @@ import time
 from collections.abc import Callable
 from typing import Any, TypeVar, cast
 
-from .decorators import LogLevels, handle_error
 from .print import BAR_FORMAT, MAGENTA
 
 
@@ -34,9 +33,8 @@ T = TypeVar("T")
 R = TypeVar("R")
 
 # Functions
-@handle_error(error_log=LogLevels.ERROR_TRACEBACK)
 def multiprocessing(
-	func: Callable[[T], R] | list[Callable[[T], R]],
+	func: Callable[..., R] | list[Callable[..., R]],
 	args: list[T],
 	use_starmap: bool = False,
 	chunksize: int = 1,
@@ -150,9 +148,8 @@ def multiprocessing(
 			return [func(arg) for arg in args]
 
 
-@handle_error(error_log=LogLevels.ERROR_TRACEBACK)
 def multithreading(
-	func: Callable[[T], R] | list[Callable[[T], R]],
+	func: Callable[..., R] | list[Callable[..., R]],
 	args: list[T],
 	use_starmap: bool = False,
 	desc: str = "",
@@ -243,10 +240,10 @@ def multithreading(
 			return [func(arg) for arg in args]
 
 
-@handle_error(error_log=LogLevels.ERROR_TRACEBACK)
 def run_in_subprocess(
 	func: Callable[..., R],
 	*args: Any,
+	timeout: float | None = None,
 	**kwargs: Any
 ) -> R:
 	""" Execute a function in a subprocess with positional and keyword arguments.
@@ -259,13 +256,16 @@ def run_in_subprocess(
 		func     (Callable): The function to execute in a subprocess.
 			(SHOULD BE A TOP-LEVEL FUNCTION TO BE PICKLABLE)
 		*args    (Any):      Positional arguments to pass to the function.
+		timeout  (float | None): Maximum time in seconds to wait for the subprocess.
+			If None, wait indefinitely. If the subprocess exceeds this time, it will be terminated.
 		**kwargs (Any):      Keyword arguments to pass to the function.
 
 	Returns:
 		R: The return value of the function.
 
 	Raises:
-		RuntimeError: If the subprocess exits with a non-zero exit code.
+		RuntimeError: If the subprocess exits with a non-zero exit code or times out.
+		TimeoutError: If the subprocess exceeds the specified timeout.
 
 	Examples:
 		.. code-block:: python
@@ -285,6 +285,9 @@ def run_in_subprocess(
 			.     return f"{greeting}, {name}!"
 			> run_in_subprocess(greet, "World", greeting="Hi")
 			'Hi, World!'
+
+			> # With timeout to prevent hanging
+			> run_in_subprocess(some_gpu_func, data, timeout=300.0)
 	"""
 	import multiprocessing as mp
 	from multiprocessing import Queue
@@ -298,20 +301,40 @@ def run_in_subprocess(
 		args=(result_queue, func, args, kwargs)
 	)
 	process.start()
-	process.join()
+
+	# Join with timeout to prevent indefinite hanging
+	process.join(timeout=timeout)
+
+	# Check if process is still alive (timed out)
+	if process.is_alive():
+		process.terminate()
+		time.sleep(0.5)  # Give it a moment to terminate gracefully
+		if process.is_alive():
+			process.kill()
+		process.join()
+		raise TimeoutError(f"Subprocess exceeded timeout of {timeout} seconds and was terminated")
 
 	# Check exit code
 	if process.exitcode != 0:
-		raise RuntimeError(f"Subprocess failed with exit code {process.exitcode}")
+		# Try to get any exception from the queue (non-blocking)
+		error_msg = f"Subprocess failed with exit code {process.exitcode}"
+		try:
+			if not result_queue.empty():
+				result_or_exception = result_queue.get_nowait()
+				if isinstance(result_or_exception, Exception):
+					raise result_or_exception
+		except Exception:
+			pass
+		raise RuntimeError(error_msg)
 
 	# Retrieve the result
-	if not result_queue.empty():
-		result_or_exception = result_queue.get()
+	try:
+		result_or_exception = result_queue.get_nowait()
 		if isinstance(result_or_exception, Exception):
 			raise result_or_exception
 		return result_or_exception
-	else:
-		raise RuntimeError("Subprocess did not return any result")
+	except Exception as e:
+		raise RuntimeError("Subprocess did not return any result") from e
 
 
 # "Private" function for subprocess wrapper (must be at module level for pickling on Windows)

{stouputils-1.9.1 → stouputils-1.9.2}/stouputils/parallel.pyi

@@ -1,4 +1,3 @@
-from .decorators import LogLevels as LogLevels, handle_error as handle_error
 from .print import BAR_FORMAT as BAR_FORMAT, MAGENTA as MAGENTA
 from collections.abc import Callable
 from typing import Any, TypeVar
@@ -10,7 +9,7 @@ CPU_COUNT: int
 T = TypeVar('T')
 R = TypeVar('R')
 
-def multiprocessing(func: Callable[[T], R] | list[Callable[[T], 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 = ..., 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.
@@ -64,7 +63,7 @@ def multiprocessing(func: Callable[[T], R] | list[Callable[[T], R]], args: list[
 \t\t\t. )
 \t\t\t[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 \t'''
-def multithreading(func: Callable[[T], R] | list[Callable[[T], 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 = ..., 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.
@@ -116,7 +115,7 @@ def multithreading(func: Callable[[T], R] | list[Callable[[T], R]], args: list[T
 \t\t\t. )
 \t\t\t[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 \t'''
-def run_in_subprocess(func: Callable[..., R], *args: Any, **kwargs: Any) -> R:
+def run_in_subprocess(func: Callable[..., R], *args: Any, timeout: float | None = None, **kwargs: Any) -> R:
     ''' Execute a function in a subprocess with positional and keyword arguments.
 
 \tThis is useful when you need to run a function in isolation to avoid memory leaks,
@@ -127,13 +126,16 @@ def run_in_subprocess(func: Callable[..., R], *args: Any, **kwargs: Any) -> R:
 \t\tfunc     (Callable): The function to execute in a subprocess.
 \t\t\t(SHOULD BE A TOP-LEVEL FUNCTION TO BE PICKLABLE)
 \t\t*args    (Any):      Positional arguments to pass to the function.
+\t\ttimeout  (float | None): Maximum time in seconds to wait for the subprocess.
+\t\t\tIf None, wait indefinitely. If the subprocess exceeds this time, it will be terminated.
 \t\t**kwargs (Any):      Keyword arguments to pass to the function.
 
 \tReturns:
 \t\tR: The return value of the function.
 
 \tRaises:
-\t\tRuntimeError: If the subprocess exits with a non-zero exit code.
+\t\tRuntimeError: If the subprocess exits with a non-zero exit code or times out.
+\t\tTimeoutError: If the subprocess exceeds the specified timeout.
 
 \tExamples:
 \t\t.. code-block:: python
@@ -153,6 +155,9 @@ def run_in_subprocess(func: Callable[..., R], *args: Any, **kwargs: Any) -> R:
 \t\t\t.     return f"{greeting}, {name}!"
 \t\t\t> run_in_subprocess(greet, "World", greeting="Hi")
 \t\t\t\'Hi, World!\'
+
+\t\t\t> # With timeout to prevent hanging
+\t\t\t> run_in_subprocess(some_gpu_func, data, timeout=300.0)
 \t'''
 def _subprocess_wrapper(result_queue: Any, func: Callable[..., R], args: tuple[Any, ...], kwargs: dict[str, Any]) -> None:
     """ Wrapper function to execute the target function and store the result in the queue.