stouputils 1.14.2__tar.gz → 1.14.3__tar.gz

{stouputils-1.14.2 → stouputils-1.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: stouputils
-Version: 1.14.2
+Version: 1.14.3
 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.
 Keywords: utilities,tools,helpers,development,python
 Author: Stoupy51

{stouputils-1.14.2 → stouputils-1.14.3}/pyproject.toml

@@ -8,7 +8,7 @@ module-root = ""
 
 [project]
 name = "stouputils"
-version = "1.14.2"
+version = "1.14.3"
 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"
 keywords = ["utilities", "tools", "helpers", "development", "python"]

{stouputils-1.14.2 → stouputils-1.14.3}/stouputils/continuous_delivery/pypi.py

@@ -110,7 +110,7 @@ def pypi_full_routine_using_uv() -> None:
 	# Generate stubs unless '--no-stubs' is passed
 	if "--no-stubs" not in sys.argv and "--no_stubs" not in sys.argv:
 		from .stubs import stubs_full_routine
-		stubs_full_routine(package_name, output_directory=package_dir, clean_before=True)
+		stubs_full_routine(package_name, output_directory=os.path.dirname(package_dir) or ".", clean_before=True)
 
 	# Increment version in pyproject.toml
 	if "--no-bump" not in sys.argv and "--no_bump" not in sys.argv:

stouputils-1.14.2/stouputils/continuous_delivery/pypi.pyi

@@ -1,52 +0,0 @@
-from ..decorators import LogLevels as LogLevels, handle_error as handle_error
-from .pyproject import read_pyproject as read_pyproject
-from collections.abc import Callable as Callable
-
-def update_pip_and_required_packages() -> int:
-    """ Update pip and required packages.
-
-\tReturns:
-\t\tint: Return code of the os.system call.
-\t"""
-def build_package() -> int:
-    """ Build the package.
-
-\tReturns:
-\t\tint: Return code of the os.system call.
-\t"""
-def upload_package(repository: str, filepath: str) -> int:
-    """ Upload the package to PyPI.
-
-\tArgs:
-\t\trepository  (str): Repository to upload to.
-\t\tfilepath    (str): Path to the file to upload.
-
-\tReturns:
-\t\tint: Return code of the os.system call.
-\t"""
-def pypi_full_routine(repository: str, dist_directory: str, last_files: int = 1, endswith: str = '.tar.gz', update_all_function: Callable[[], int] = ..., build_package_function: Callable[[], int] = ..., upload_package_function: Callable[[str, str], int] = ...) -> None:
-    ''' Upload the most recent file(s) to PyPI after updating pip and required packages and building the package.
-
-\tArgs:
-\t\trepository               (str):                        Repository to upload to.
-\t\tdist_directory           (str):                        Directory to upload from.
-\t\tlast_files               (int):                        Number of most recent files to upload. Defaults to 1.
-\t\tendswith                 (str):                        End of the file name to upload. Defaults to ".tar.gz".
-\t\tupdate_all_function      (Callable[[], int]):          Function to update pip and required packages.
-\t\t\tDefaults to :func:`update_pip_and_required_packages`.
-\t\tbuild_package_function   (Callable[[], int]):          Function to build the package.
-\t\t\tDefaults to :func:`build_package`.
-\t\tupload_package_function  (Callable[[str, str], int]):  Function to upload the package.
-\t\t\tDefaults to :func:`upload_package`.
-
-\tReturns:
-\t\tint: Return code of the command.
-\t'''
-def pypi_full_routine_using_uv() -> None:
-    """ Full build and publish routine using 'uv' command line tool.
-
-\tSteps:
-\t\t1. Generate stubs unless '--no-stubs' is passed
-\t\t2. Build the package using 'uv build'
-\t\t3. Upload the most recent file to PyPI using 'uv publish'
-\t"""

stouputils-1.14.2/stouputils/decorators.pyi

@@ -1,242 +0,0 @@
-from .ctx import MeasureTime as MeasureTime, Muffle as Muffle
-from .print import error as error, progress as progress, warning as warning
-from collections.abc import Callable as Callable
-from enum import Enum
-from typing import Any, Literal
-
-def measure_time(func: Callable[..., Any] | None = None, *, printer: Callable[..., None] = ..., message: str = '', perf_counter: bool = True, is_generator: bool = False) -> Callable[..., Any]:
-    ''' Decorator that will measure the execution time of a function and print it with the given print function
-
-\tArgs:
-\t\tfunc\t\t\t(Callable[..., Any] | None): Function to decorate
-\t\tprinter\t\t\t(Callable):\tFunction to use to print the execution time (e.g. debug, info, warning, error, etc.)
-\t\tmessage\t\t\t(str):\t\tMessage to display with the execution time (e.g. "Execution time of Something"),
-\t\t\tdefaults to "Execution time of {func.__name__}"
-\t\tperf_counter\t(bool):\t\tWhether to use time.perf_counter_ns or time.time_ns
-\t\t\tdefaults to True (use time.perf_counter_ns)
-\t\tis_generator\t(bool):\t\tWhether the function is a generator or not (default: False)
-\t\t\tWhen True, the decorator will yield from the function instead of returning it.
-
-\tReturns:
-\t\tCallable: Decorator to measure the time of the function.
-
-\tExamples:
-\t\t.. code-block:: python
-
-\t\t\t> @measure_time(printer=info)
-\t\t\t> def test():
-\t\t\t>     pass
-\t\t\t> test()  # [INFO HH:MM:SS] Execution time of test: 0.000ms (400ns)
-\t'''
-
-class LogLevels(Enum):
-    """ Log level for the errors in the decorator handle_error() """
-    NONE = 0
-    WARNING = 1
-    WARNING_TRACEBACK = 2
-    ERROR_TRACEBACK = 3
-    RAISE_EXCEPTION = 4
-
-force_raise_exception: bool
-
-def handle_error(func: Callable[..., Any] | None = None, *, exceptions: tuple[type[BaseException], ...] | type[BaseException] = ..., message: str = '', error_log: LogLevels = ..., sleep_time: float = 0.0) -> Callable[..., Any]:
-    ''' Decorator that handle an error with different log levels.
-
-\tArgs:
-\t\tfunc        (Callable[..., Any] | None):    \tFunction to decorate
-\t\texceptions\t(tuple[type[BaseException]], ...):\tExceptions to handle
-\t\tmessage\t\t(str):\t\t\t\t\t\t\t\tMessage to display with the error. (e.g. "Error during something")
-\t\terror_log\t(LogLevels):\t\t\t\t\t\tLog level for the errors
-\t\t\tLogLevels.NONE:\t\t\t\t\tNone
-\t\t\tLogLevels.WARNING:\t\t\t\tShow as warning
-\t\t\tLogLevels.WARNING_TRACEBACK:\tShow as warning with traceback
-\t\t\tLogLevels.ERROR_TRACEBACK:\t\tShow as error with traceback
-\t\t\tLogLevels.RAISE_EXCEPTION:\t\tRaise exception
-\t\tsleep_time\t(float):\t\t\t\t\t\t\tTime to sleep after the error (e.g. 0.0 to not sleep, 1.0 to sleep for 1 second)
-
-\tExamples:
-\t\t>>> @handle_error
-\t\t... def might_fail():
-\t\t...     raise ValueError("Let\'s fail")
-
-\t\t>>> @handle_error(error_log=LogLevels.WARNING)
-\t\t... def test():
-\t\t...     raise ValueError("Let\'s fail")
-\t\t>>> # test()\t# [WARNING HH:MM:SS] Error during test: (ValueError) Let\'s fail
-\t'''
-def timeout(func: Callable[..., Any] | None = None, *, seconds: float = 60.0, message: str = '') -> Callable[..., Any]:
-    ''' Decorator that raises a TimeoutError if the function runs longer than the specified timeout.
-
-\tNote: This decorator uses SIGALRM on Unix systems, which only works in the main thread.
-\tOn Windows or in non-main threads, it will fall back to a polling-based approach.
-
-\tArgs:
-\t\tfunc\t\t(Callable[..., Any] | None):\tFunction to apply timeout to
-\t\tseconds\t\t(float):\t\t\t\t\t\tTimeout duration in seconds (default: 60.0)
-\t\tmessage\t\t(str):\t\t\t\t\t\t\tCustom timeout message (default: "Function \'{func_name}\' timed out after {seconds} seconds")
-
-\tReturns:
-\t\tCallable[..., Any]: Decorator that enforces timeout on the function
-
-\tRaises:
-\t\tTimeoutError: If the function execution exceeds the timeout duration
-
-\tExamples:
-\t\t>>> @timeout(seconds=2.0)
-\t\t... def slow_function():
-\t\t...     time.sleep(5)
-\t\t>>> slow_function()  # Raises TimeoutError after 2 seconds
-\t\tTraceback (most recent call last):
-\t\t\t...
-\t\tTimeoutError: Function \'slow_function\' timed out after 2.0 seconds
-
-\t\t>>> @timeout(seconds=1.0, message="Custom timeout message")
-\t\t... def another_slow_function():
-\t\t...     time.sleep(3)
-\t\t>>> another_slow_function()  # Raises TimeoutError after 1 second
-\t\tTraceback (most recent call last):
-\t\t\t...
-\t\tTimeoutError: Custom timeout message
-\t'''
-def retry(func: Callable[..., Any] | None = None, *, exceptions: tuple[type[BaseException], ...] | type[BaseException] = ..., max_attempts: int = 10, delay: float = 1.0, backoff: float = 1.0, message: str = '') -> Callable[..., Any]:
-    ''' Decorator that retries a function when specific exceptions are raised.
-
-\tArgs:
-\t\tfunc\t\t\t(Callable[..., Any] | None):\t\tFunction to retry
-\t\texceptions\t\t(tuple[type[BaseException], ...]):\tExceptions to catch and retry on
-\t\tmax_attempts\t(int | None):\t\t\t\t\t\tMaximum number of attempts (None for infinite retries)
-\t\tdelay\t\t\t(float):\t\t\t\t\t\t\tInitial delay in seconds between retries (default: 1.0)
-\t\tbackoff\t\t\t(float):\t\t\t\t\t\t\tMultiplier for delay after each retry (default: 1.0 for constant delay)
-\t\tmessage\t\t\t(str):\t\t\t\t\t\t\t\tCustom message to display before ", retrying" (default: "{ExceptionName} encountered while running {func_name}")
-
-\tReturns:
-\t\tCallable[..., Any]: Decorator that retries the function on specified exceptions
-
-\tExamples:
-\t\t>>> import os
-\t\t>>> @retry(exceptions=PermissionError, max_attempts=3, delay=0.1)
-\t\t... def write_file():
-\t\t...     with open("test.txt", "w") as f:
-\t\t...         f.write("test")
-
-\t\t>>> @retry(exceptions=(OSError, IOError), delay=0.5, backoff=2.0)
-\t\t... def network_call():
-\t\t...     pass
-
-\t\t>>> @retry(max_attempts=5, delay=1.0)
-\t\t... def might_fail():
-\t\t...     pass
-\t'''
-def simple_cache(func: Callable[..., Any] | None = None, *, method: Literal['str', 'pickle'] = 'str') -> Callable[..., Any]:
-    ''' Decorator that caches the result of a function based on its arguments.
-
-\tThe str method is often faster than the pickle method (by a little) but not as accurate with complex objects.
-
-\tArgs:
-\t\tfunc   (Callable[..., Any] | None): Function to cache
-\t\tmethod (Literal["str", "pickle"]):  The method to use for caching.
-\tReturns:
-\t\tCallable[..., Any]: A decorator that caches the result of a function.
-\tExamples:
-\t\t>>> @simple_cache
-\t\t... def test1(a: int, b: int) -> int:
-\t\t...     return a + b
-
-\t\t>>> @simple_cache(method="str")
-\t\t... def test2(a: int, b: int) -> int:
-\t\t...     return a + b
-\t\t>>> test2(1, 2)
-\t\t3
-\t\t>>> test2(1, 2)
-\t\t3
-\t\t>>> test2(3, 4)
-\t\t7
-\t'''
-def abstract(func: Callable[..., Any] | None = None, *, error_log: LogLevels = ...) -> Callable[..., Any]:
-    """ Decorator that marks a function as abstract.
-
-\tContrary to the abstractmethod decorator from the abc module that raises a TypeError
-\twhen you try to instantiate a class that has abstract methods, this decorator raises
-\ta NotImplementedError ONLY when the decorated function is called, indicating that the function
-\tmust be implemented by a subclass.
-
-\tArgs:
-\t\tfunc                (Callable[..., Any] | None): The function to mark as abstract
-\t\terror_log           (LogLevels):                 Log level for the error handling
-\t\t\tLogLevels.NONE:              None
-\t\t\tLogLevels.WARNING:           Show as warning
-\t\t\tLogLevels.WARNING_TRACEBACK: Show as warning with traceback
-\t\t\tLogLevels.ERROR_TRACEBACK:   Show as error with traceback
-\t\t\tLogLevels.RAISE_EXCEPTION:   Raise exception
-
-\tReturns:
-\t\tCallable[..., Any]: Decorator that raises NotImplementedError when called
-
-\tExamples:
-\t\t>>> class Base:
-\t\t...     @abstract
-\t\t...     def method(self):
-\t\t...         pass
-\t\t>>> Base().method()
-\t\tTraceback (most recent call last):
-\t\t\t...
-\t\tNotImplementedError: Function 'method' is abstract and must be implemented by a subclass
-\t"""
-def deprecated(func: Callable[..., Any] | None = None, *, message: str = '', version: str = '', error_log: LogLevels = ...) -> Callable[..., Any]:
-    ''' Decorator that marks a function as deprecated.
-
-\tArgs:
-\t\tfunc        (Callable[..., Any] | None): Function to mark as deprecated
-\t\tmessage     (str):                       Additional message to display with the deprecation warning
-\t\tversion     (str):                       Version since when the function is deprecated (e.g. "v1.2.0")
-\t\terror_log   (LogLevels):                 Log level for the deprecation warning
-\t\t\tLogLevels.NONE:              None
-\t\t\tLogLevels.WARNING:           Show as warning
-\t\t\tLogLevels.WARNING_TRACEBACK: Show as warning with traceback
-\t\t\tLogLevels.ERROR_TRACEBACK:   Show as error with traceback
-\t\t\tLogLevels.RAISE_EXCEPTION:   Raise exception
-\tReturns:
-\t\tCallable[..., Any]: Decorator that marks a function as deprecated
-
-\tExamples:
-\t\t>>> @deprecated
-\t\t... def old_function():
-\t\t...     pass
-
-\t\t>>> @deprecated(message="Use \'new_function()\' instead", error_log=LogLevels.WARNING)
-\t\t... def another_old_function():
-\t\t...     pass
-\t'''
-def silent(func: Callable[..., Any] | None = None, *, mute_stderr: bool = False) -> Callable[..., Any]:
-    ''' Decorator that makes a function silent (disable stdout, and stderr if specified).
-
-\tAlternative to stouputils.ctx.Muffle.
-
-\tArgs:
-\t\tfunc\t\t\t(Callable[..., Any] | None):\tFunction to make silent
-\t\tmute_stderr\t\t(bool):\t\t\t\t\t\t\tWhether to mute stderr or not
-
-\tExamples:
-\t\t>>> @silent
-\t\t... def test():
-\t\t...     print("Hello, world!")
-\t\t>>> test()
-
-\t\t>>> @silent(mute_stderr=True)
-\t\t... def test2():
-\t\t...     print("Hello, world!")
-\t\t>>> test2()
-
-\t\t>>> silent(print)("Hello, world!")
-\t'''
-def _get_func_name(func: Callable[..., Any]) -> str:
-    ''' Get the name of a function, returns "<unknown>" if the name cannot be retrieved. '''
-def _get_wrapper_name(decorator_name: str, func: Callable[..., Any]) -> str:
-    ''' Get a descriptive name for a wrapper function.
-
-\tArgs:
-\t\tdecorator_name\t(str):\t\t\t\t\tName of the decorator
-\t\tfunc\t\t\t(Callable[..., Any]):\tFunction being decorated
-\tReturns:
-\t\tstr: Combined name for the wrapper function (e.g., "stouputils.decorators.handle_error@function_name")
-\t'''

stouputils-1.14.2/stouputils/parallel.pyi

@@ -1,211 +0,0 @@
-from .ctx import SetMPStartMethod as SetMPStartMethod
-from .print import BAR_FORMAT as BAR_FORMAT, MAGENTA as MAGENTA
-from collections.abc import Callable, Iterable
-from typing import Any, TypeVar
-
-def doctest_square(x: int) -> int: ...
-def doctest_slow(x: int) -> int: ...
-
-CPU_COUNT: int
-T = TypeVar('T')
-R = TypeVar('R')
-
-def multiprocessing[T, R](func: Callable[..., R] | list[Callable[..., R]], args: Iterable[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.
-\t- When the task can be divided into smaller, independent sub-tasks that can be executed concurrently.
-\t- For computationally intensive tasks like scientific simulations, data analysis, or machine learning workloads.
-
-\tArgs:
-\t\tfunc\t\t\t\t(Callable | list[Callable]):\tFunction to execute, or list of functions (one per argument)
-\t\targs\t\t\t\t(Iterable):\t\t\tIterable of arguments to pass to the function(s)
-\t\tuse_starmap\t\t\t(bool):\t\t\t\tWhether to use starmap or not (Defaults to False):
-\t\t\tTrue means the function will be called like func(\\*args[i]) instead of func(args[i])
-\t\tchunksize\t\t\t(int):\t\t\t\tNumber of arguments to process at a time
-\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 | 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.
-\t\tcolor\t\t\t\t(str):\t\t\t\tColor of the progress bar (Defaults to MAGENTA)
-\t\tbar_format\t\t\t(str):\t\t\t\tFormat of the progress bar (Defaults to BAR_FORMAT)
-\t\tascii\t\t\t\t(bool):\t\t\t\tWhether to use ASCII or Unicode characters for the progress bar
-
-\tReturns:
-\t\tlist[object]:\tResults of the function execution
-
-\tExamples:
-\t\t.. code-block:: python
-
-\t\t\t> multiprocessing(doctest_square, args=[1, 2, 3])
-\t\t\t[1, 4, 9]
-
-\t\t\t> multiprocessing(int.__mul__, [(1,2), (3,4), (5,6)], use_starmap=True)
-\t\t\t[2, 12, 30]
-
-\t\t\t> # Using a list of functions (one per argument)
-\t\t\t> multiprocessing([doctest_square, doctest_square, doctest_square], [1, 2, 3])
-\t\t\t[1, 4, 9]
-
-\t\t\t> # Will process in parallel with progress bar
-\t\t\t> multiprocessing(doctest_slow, range(10), desc="Processing")
-\t\t\t[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-\t\t\t> # Will process in parallel with progress bar and delay the first threads
-\t\t\t> multiprocessing(
-\t\t\t.     doctest_slow,
-\t\t\t.     range(10),
-\t\t\t.     desc="Processing with delay",
-\t\t\t.     max_workers=2,
-\t\t\t.     delay_first_calls=0.6
-\t\t\t. )
-\t\t\t[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-\t'''
-def multithreading[T, R](func: Callable[..., R] | list[Callable[..., R]], args: Iterable[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.
-\t- When the task involves waiting for external resources, such as network responses or user input.
-\t- For operations that involve a lot of waiting, such as GUI event handling or handling user input.
-
-\tArgs:
-\t\tfunc\t\t\t\t(Callable | list[Callable]):\tFunction to execute, or list of functions (one per argument)
-\t\targs\t\t\t\t(Iterable):\t\t\tIterable of arguments to pass to the function(s)
-\t\tuse_starmap\t\t\t(bool):\t\t\t\tWhether to use starmap or not (Defaults to False):
-\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 | 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.
-\t\tcolor\t\t\t\t(str):\t\t\t\tColor of the progress bar (Defaults to MAGENTA)
-\t\tbar_format\t\t\t(str):\t\t\t\tFormat of the progress bar (Defaults to BAR_FORMAT)
-\t\tascii\t\t\t\t(bool):\t\t\t\tWhether to use ASCII or Unicode characters for the progress bar
-
-\tReturns:
-\t\tlist[object]:\tResults of the function execution
-
-\tExamples:
-\t\t.. code-block:: python
-
-\t\t\t> multithreading(doctest_square, args=[1, 2, 3])
-\t\t\t[1, 4, 9]
-
-\t\t\t> multithreading(int.__mul__, [(1,2), (3,4), (5,6)], use_starmap=True)
-\t\t\t[2, 12, 30]
-
-\t\t\t> # Using a list of functions (one per argument)
-\t\t\t> multithreading([doctest_square, doctest_square, doctest_square], [1, 2, 3])
-\t\t\t[1, 4, 9]
-
-\t\t\t> # Will process in parallel with progress bar
-\t\t\t> multithreading(doctest_slow, range(10), desc="Threading")
-\t\t\t[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-\t\t\t> # Will process in parallel with progress bar and delay the first threads
-\t\t\t> multithreading(
-\t\t\t.     doctest_slow,
-\t\t\t.     range(10),
-\t\t\t.     desc="Threading with delay",
-\t\t\t.     max_workers=2,
-\t\t\t.     delay_first_calls=0.6
-\t\t\t. )
-\t\t\t[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-\t'''
-def run_in_subprocess[R](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,
-\tresource conflicts, or to ensure a clean execution environment. The subprocess will
-\tbe created, run the function with the provided arguments, and return the result.
-
-\tArgs:
-\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 or times out.
-\t\tTimeoutError: If the subprocess exceeds the specified timeout.
-
-\tExamples:
-\t\t.. code-block:: python
-
-\t\t\t> # Simple function execution
-\t\t\t> run_in_subprocess(doctest_square, 5)
-\t\t\t25
-
-\t\t\t> # Function with multiple arguments
-\t\t\t> def add(a: int, b: int) -> int:
-\t\t\t.     return a + b
-\t\t\t> run_in_subprocess(add, 10, 20)
-\t\t\t30
-
-\t\t\t> # Function with keyword arguments
-\t\t\t> def greet(name: str, greeting: str = "Hello") -> str:
-\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[R](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.
-
-\tMust be at module level to be pickable on Windows (spawn context).
-
-\tArgs:
-\t\tresult_queue (multiprocessing.Queue):  Queue to store the result or exception.
-\t\tfunc         (Callable):               The target function to execute.
-\t\targs         (tuple):                  Positional arguments for the function.
-\t\tkwargs       (dict):                   Keyword arguments for the function.
-\t"""
-def _starmap[T, R](args: tuple[Callable[[T], R], list[T]]) -> R:
-    """ Private function to use starmap using args[0](\\*args[1])
-
-\tArgs:
-\t\targs (tuple): Tuple containing the function and the arguments list to pass to the function
-\tReturns:
-\t\tobject: Result of the function execution
-\t"""
-def _delayed_call[T, R](args: tuple[Callable[[T], R], float, T]) -> R:
-    """ Private function to apply delay before calling the target function
-
-\tArgs:
-\t\targs (tuple): Tuple containing the function, delay in seconds, and the argument to pass to the function
-\tReturns:
-\t\tobject: Result of the function execution
-\t"""
-def _handle_parameters[T, R](func: Callable[[T], R] | list[Callable[[T], R]], args: list[T], use_starmap: bool, delay_first_calls: float, max_workers: int, desc: str, color: str) -> tuple[str, Callable[[T], R], list[T]]:
-    ''' Private function to handle the parameters for multiprocessing or multithreading functions
-
-\tArgs:
-\t\tfunc\t\t\t\t(Callable | list[Callable]):\tFunction to execute, or list of functions (one per argument)
-\t\targs\t\t\t\t(list):\t\t\t\tList of arguments to pass to the function(s)
-\t\tuse_starmap\t\t\t(bool):\t\t\t\tWhether to use starmap or not (Defaults to False):
-\t\t\tTrue means the function will be called like func(\\*args[i]) instead of func(args[i])
-\t\tdelay_first_calls\t(int):\t\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. (Defaults to 0):
-\t\t\tThis can be useful to avoid functions being called in the same second.
-\t\tmax_workers\t\t\t(int):\t\t\t\tNumber of workers to use (Defaults to CPU_COUNT)
-\t\tdesc\t\t\t\t(str):\t\t\t\tDescription of the function execution displayed in the progress bar
-\t\tcolor\t\t\t\t(str):\t\t\t\tColor of the progress bar
-
-\tReturns:
-\t\ttuple[str, Callable[[T], R], list[T]]:\tTuple containing the description, function, and arguments
-\t'''

stouputils-1.14.2/stouputils/print.pyi

@@ -1,136 +0,0 @@
-from collections.abc import Callable as Callable, Iterable, Iterator
-from typing import Any, IO, TextIO, TypeVar
-
-RESET: str
-RED: str
-GREEN: str
-YELLOW: str
-BLUE: str
-MAGENTA: str
-CYAN: str
-LINE_UP: str
-BAR_FORMAT: str
-T = TypeVar('T')
-previous_args_kwards: tuple[Any, Any]
-nb_values: int
-import_time: float
-
-def colored_for_loop[T](iterable: Iterable[T], desc: str = 'Processing', color: str = ..., bar_format: str = ..., ascii: bool = False, **kwargs: Any) -> Iterator[T]:
-    ''' Function to iterate over a list with a colored TQDM progress bar like the other functions in this module.
-
-\tArgs:
-\t\titerable\t(Iterable):\t\t\tList to iterate over
-\t\tdesc\t\t(str):\t\t\t\tDescription of the function execution displayed in the progress bar
-\t\tcolor\t\t(str):\t\t\t\tColor of the progress bar (Defaults to MAGENTA)
-\t\tbar_format\t(str):\t\t\t\tFormat of the progress bar (Defaults to BAR_FORMAT)
-\t\tascii\t\t(bool):\t\t\t\tWhether to use ASCII or Unicode characters for the progress bar (Defaults to False)
-\t\tverbose\t\t(int):\t\t\t\tLevel of verbosity, decrease by 1 for each depth (Defaults to 1)
-\t\t**kwargs:\t\t\t\t\t\tAdditional arguments to pass to the TQDM progress bar
-
-\tYields:
-\t\tT: Each item of the iterable
-
-\tExamples:
-\t\t>>> for i in colored_for_loop(range(10), desc="Time sleeping loop"):
-\t\t...     time.sleep(0.01)
-\t\t>>> # Time sleeping loop: 100%|██████████████████| 10/10 [ 95.72it/s, 00:00<00:00]
-\t'''
-def info(*values: Any, color: str = ..., text: str = 'INFO ', prefix: str = '', file: TextIO | list[TextIO] | None = None, **print_kwargs: Any) -> None:
-    ''' Print an information message looking like "[INFO HH:MM:SS] message" in green by default.
-
-\tArgs:
-\t\tvalues\t\t\t(Any):\t\t\t\t\tValues to print (like the print function)
-\t\tcolor\t\t\t(str):\t\t\t\t\tColor of the message (default: GREEN)
-\t\ttext\t\t\t(str):\t\t\t\t\tText of the message (default: "INFO ")
-\t\tprefix\t\t\t(str):\t\t\t\t\tPrefix to add to the values
-\t\tfile\t\t\t(TextIO|list[TextIO]):\tFile(s) to write the message to (default: sys.stdout)
-\t\tprint_kwargs\t(dict):\t\t\t\t\tKeyword arguments to pass to the print function
-\t'''
-def debug(*values: Any, **print_kwargs: Any) -> None:
-    ''' Print a debug message looking like "[DEBUG HH:MM:SS] message" in cyan by default. '''
-def alt_debug(*values: Any, **print_kwargs: Any) -> None:
-    ''' Print a debug message looking like "[DEBUG HH:MM:SS] message" in blue by default. '''
-def suggestion(*values: Any, **print_kwargs: Any) -> None:
-    ''' Print a suggestion message looking like "[SUGGESTION HH:MM:SS] message" in cyan by default. '''
-def progress(*values: Any, **print_kwargs: Any) -> None:
-    ''' Print a progress message looking like "[PROGRESS HH:MM:SS] message" in magenta by default. '''
-def warning(*values: Any, **print_kwargs: Any) -> None:
-    ''' Print a warning message looking like "[WARNING HH:MM:SS] message" in yellow by default and in sys.stderr. '''
-def error(*values: Any, exit: bool = False, **print_kwargs: Any) -> None:
-    """ Print an error message (in sys.stderr and in red by default)
-\tand optionally ask the user to continue or stop the program.
-
-\tArgs:
-\t\tvalues\t\t\t(Any):\t\tValues to print (like the print function)
-\t\texit\t\t\t(bool):\t\tWhether to ask the user to continue or stop the program,
-\t\t\tfalse to ignore the error automatically and continue
-\t\tprint_kwargs\t(dict):\t\tKeyword arguments to pass to the print function
-\t"""
-def whatisit(*values: Any, print_function: Callable[..., None] = ..., max_length: int = 250, color: str = ..., **print_kwargs: Any) -> None:
-    ''' Print the type of each value and the value itself, with its id and length/shape.
-
-\tThe output format is: "type, <id id_number>:\t(length/shape) value"
-
-\tArgs:
-\t\tvalues\t\t\t(Any):\t\tValues to print
-\t\tprint_function\t(Callable):\tFunction to use to print the values (default: debug())
-\t\tmax_length\t\t(int):\t\tMaximum length of the value string to print (default: 250)
-\t\tcolor\t\t\t(str):\t\tColor of the message (default: CYAN)
-\t\tprint_kwargs\t(dict):\t\tKeyword arguments to pass to the print function
-\t'''
-def breakpoint(*values: Any, print_function: Callable[..., None] = ..., **print_kwargs: Any) -> None:
-    """ Breakpoint function, pause the program and print the values.
-
-\tArgs:
-\t\tvalues\t\t\t(Any):\t\tValues to print
-\t\tprint_function\t(Callable):\tFunction to use to print the values (default: warning())
-\t\tprint_kwargs\t(dict):\t\tKeyword arguments to pass to the print function
-\t"""
-
-class TeeMultiOutput:
-    ''' File-like object that duplicates output to multiple file-like objects.
-
-\tArgs:
-\t\t*files         (IO[Any]):  One or more file-like objects that have write and flush methods
-\t\tstrip_colors   (bool):     Strip ANSI color codes from output sent to non-stdout/stderr files
-\t\tascii_only     (bool):     Replace non-ASCII characters with their ASCII equivalents for non-stdout/stderr files
-\t\tignore_lineup  (bool):     Ignore lines containing LINE_UP escape sequence in non-terminal outputs
-
-\tExamples:
-\t\t>>> f = open("logfile.txt", "w")
-\t\t>>> sys.stdout = TeeMultiOutput(sys.stdout, f)
-\t\t>>> print("Hello World")  # Output goes to both console and file
-\t\tHello World
-\t\t>>> f.close()\t# TeeMultiOutput will handle any future writes to closed files gracefully
-\t'''
-    files: tuple[IO[Any], ...]
-    strip_colors: bool
-    ascii_only: bool
-    ignore_lineup: bool
-    def __init__(self, *files: IO[Any], strip_colors: bool = True, ascii_only: bool = True, ignore_lineup: bool = True) -> None: ...
-    @property
-    def encoding(self) -> str:
-        ''' Get the encoding of the first file, or "utf-8" as fallback.
-
-\t\tReturns:
-\t\t\tstr: The encoding, ex: "utf-8", "ascii", "latin1", etc.
-\t\t'''
-    def write(self, obj: str) -> int:
-        """ Write the object to all files while stripping colors if needed.
-
-\t\tArgs:
-\t\t\tobj (str): String to write
-\t\tReturns:
-\t\t\tint: Number of characters written to the first file
-\t\t"""
-    def flush(self) -> None:
-        """ Flush all files. """
-    def fileno(self) -> int:
-        """ Return the file descriptor of the first file. """
-
-def remove_colors(text: str) -> str:
-    """ Remove the colors from a text """
-def is_same_print(*args: Any, **kwargs: Any) -> bool:
-    """ Checks if the current print call is the same as the previous one. """
-def current_time() -> str:
-    ''' Get the current time as "HH:MM:SS" if less than 24 hours since import, else "YYYY-MM-DD HH:MM:SS" '''