parameterrun 0.4.0__tar.gz → 0.4.1__tar.gz

{parameterrun-0.4.0 → parameterrun-0.4.1}/CHANGELOG.md

@@ -6,6 +6,17 @@ The format is based on Keep a Changelog and the project follows Semantic Version
 
 ## [Unreleased]
 
+## [0.4.1] - 2026-04-21
+
+### Fixed
+
+- Fix the display of the progress bar when running with `backend="joblib"`, since the previous implementation didn't
+  have access to the total number of runs to compute, which is required for the progress bar to work properly.
+
+### Added
+
+- Added a test for the progress bar display when running with `backend="joblib"`.
+
 ## [0.4.0] - 2026-04-21
 
 ### Added

{parameterrun-0.4.0 → parameterrun-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parameterrun
-Version: 0.4.0
+Version: 0.4.1
 Summary: Parallel parameter sweeps with joblib/MPI and tqdm progress bars.
 Project-URL: Homepage, https://github.com/Davtax/ParameterRun
 Project-URL: Repository, https://github.com/Davtax/ParameterRun

parameterrun-0.4.1/examples/long_example.py

@@ -0,0 +1,16 @@
+from time import sleep
+
+import numpy as np
+
+from parameterrun import parameterrun
+
+
+def f(x, y, scale=1):
+    sleep(0.1)  # Simulate a long computation
+    return scale * (x + y)
+
+
+xs = np.linspace(0, 10, 1000)
+ys = np.linspace(0, 20, 500)
+
+result = parameterrun(f, param_names=[["x"], ["y"]], param_values=[[xs], [ys]], n_workers=1, scale=2, )

{parameterrun-0.4.0 → parameterrun-0.4.1}/src/parameterrun/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 
 from .parallel_utils import parameterrun
 

{parameterrun-0.4.0 → parameterrun-0.4.1}/src/parameterrun/parallel_utils.py

@@ -60,20 +60,21 @@ def tqdm_joblib(tqdm_object: tqdm):
 
 def _parameterrun_joblib(fun: Callable[..., Any], param_names: List[List[str]], param_values: List[List[List]],
                          indices_iterate: Iterable, desc, n_workers: Optional[int] = -1, pbar_bool: bool = True,
-                         leave: Optional[bool] = True, **fun_kwargs) -> Tuple[List[List], int]:
+                         pbar_leave: Optional[bool] = True, **fun_kwargs) -> Tuple[List[List], int]:
+    n_values = [len(group[0]) for group in param_values]
+    n_total = prod(n_values)  # Compute the total number of iterations
+
     result = []
     if n_workers == 1:  # If only one worker, do not use joblib
-        pbar = tqdm(indices_iterate, desc=desc, leave=leave, disable=not pbar_bool)
+        pbar = tqdm(indices_iterate, total=n_total, desc=desc, leave=pbar_leave, disable=not pbar_bool)
         for index in pbar:
             result.append(fun(**{**_get_iteration(index, param_names, param_values), **fun_kwargs}))
     else:
-        with tqdm_joblib(tqdm(indices_iterate, desc=desc, leave=leave, disable=not pbar_bool)) as _:
+        with tqdm_joblib(tqdm(indices_iterate, total=n_total, desc=desc, leave=pbar_leave, disable=not pbar_bool)) as _:
             result = Parallel(n_jobs=n_workers)(
                 delayed(fun)(**{**_get_iteration(index, param_names, param_values), **fun_kwargs}) for index in
                 indices_iterate)
 
-    n_total = len(result)
-
     n_output = len(result[0]) if isinstance(result[0], tuple) else 1
     if n_output == 1:
         result = [(result_i,) for result_i in result]
@@ -97,7 +98,7 @@ def _product_element_from_index(lists: List[Any], k: int) -> List:
 
 def _parameterrun_mpi(fun: Callable[..., Any], param_names: List[List[str]], param_values: List[List[List]],
                       desc: Optional[str], pbar_bool: bool = True, verbose: Optional[bool] = False,
-                      leave: Optional[bool] = True, seed=None, **fun_kwargs) -> Tuple[
+                      pbar_leave: Optional[bool] = True, seed=None, **fun_kwargs) -> Tuple[
     List[List], int]:  # pragma: no cover
     from mpi4py import MPI
 
@@ -120,12 +121,11 @@ def _parameterrun_mpi(fun: Callable[..., Any], param_names: List[List[str]], par
     total_indices = comm.bcast(total_indices, root=0)
     indices_compute = np.array_split(total_indices, size)[rank]
 
-    # groups_compute = np.array(groups_iterate)[indices_compute]
     groups_compute = []
     for index in indices_compute:
         groups_compute.append(_product_element_from_index(indices, index))
 
-    pbar = tqdm(groups_compute, desc=desc, leave=leave, disable=not (pbar_bool and rank == 0), file=sys.stdout)
+    pbar = tqdm(groups_compute, desc=desc, leave=pbar_leave, disable=not (pbar_bool and rank == 0), file=sys.stdout)
 
     n_outputs = 0
     result: List[Any] = []
@@ -159,7 +159,8 @@ def _parameterrun_mpi(fun: Callable[..., Any], param_names: List[List[str]], par
     # Notify root when each worker is done, and show a progress bar
     if rank == 0:
         progress = 0
-        pbar = tqdm(total=size - 1, desc='Waiting for workers', leave=leave, disable=not pbar_bool, file=sys.stdout)
+        pbar = tqdm(total=size - 1, desc='Waiting for workers', leave=pbar_leave, disable=not pbar_bool,
+                    file=sys.stdout)
 
         while progress < size - 1:
             if comm.Iprobe(source=MPI.ANY_SOURCE, tag=0):
@@ -189,6 +190,7 @@ def _parameterrun_mpi(fun: Callable[..., Any], param_names: List[List[str]], par
         _log('Results gathered', verbose and rank == 0, hostname=MPI.Get_processor_name())
 
         if rank == 0:
+            assert result_gathered is not None  # For type checker
             result_gathered = [item for sublist in result_gathered for item in sublist]  # Flatten the list
 
             results_unshuffled = [None] * n_total
@@ -341,9 +343,10 @@ def _convert_result_to_lists(result: Any) -> Any:
 
 def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], List[List[str]]],
                  param_values: Union[Iterable[Any], Iterable[Iterable[Any]], Iterable[Iterable[Iterable[Any]]]],
-                 n_workers: Optional[int] = -1, pbar_bool: bool = True, verbose: Optional[bool] = False,
-                 reshape: bool = True, result_as_array: bool = True, backend: Optional[str] = None,
-                 desc: Optional[str] = None, **kwargs) -> Union[list, np.ndarray, None]:  # noqa: E501
+                 n_workers: Optional[int] = -1, pbar_bool: bool = True, pbar_leave: bool = True,
+                 verbose: Optional[bool] = False, reshape: bool = True, result_as_array: bool = True,
+                 backend: Optional[str] = None, desc: Optional[str] = None, **fun_kwargs) -> Union[
+    list, np.ndarray, None]:  # noqa: E501
     """
     Run a function with multiple parameters in parallel. To indentify the parameters of interest, user must provide its
     name as is written in the function definition. If more parameters should be pass to the function, they can be
@@ -376,6 +379,8 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
         Number of workers to use in parallel. If -1, the number of workers is the maximum number of cores available.
     pbar_bool : bool, optional (default=True)
         If True, show a progress bar.
+    pbar_leave : bool, optional (default=True)
+        If True, leave the progress bar after completion.
     backend : str, optional (default=None)
         Backend to use for the parallelization. If None, the backend is chosen automatically between joblib and mpi.
     verbose : bool, optional (default=False)
@@ -388,7 +393,7 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
         lists.
     desc: str, optional (default=None)
         Description of the progress bar. If None, the description denotes the function and parameters names.
-    kwargs :
+    fun_kwargs :
         Additional parameters to pass to the function.
 
     Returns
@@ -401,7 +406,7 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
     time_start = time()
 
     formatted_param_names, formatted_param_values = _format_input(param_names, param_values)
-    _validate_function_arguments(fun, formatted_param_names, kwargs)
+    _validate_function_arguments(fun, formatted_param_names, fun_kwargs)
 
     # Create the list of dictionaries with the parameters in a nested loop
     n_values = [len(group[0]) for group in formatted_param_values]
@@ -452,14 +457,15 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
         indices = [list(range(n_value)) for n_value in n_values]
         indices_iterate = product(*indices)
         result, n_outputs = _parameterrun_joblib(fun, formatted_param_names, formatted_param_values, indices_iterate,
-                                                 desc, n_workers=n_workers, pbar_bool=pbar_bool, **kwargs)
+                                                 desc, n_workers=n_workers, pbar_bool=pbar_bool, pbar_leave=pbar_leave,
+                                                 **fun_kwargs)
 
     elif backend == 'mpi':
         _log(f'Running under mpi with {size} workers', verbose and rank == 0,
              hostname=mpi_module.Get_processor_name() if mpi_module is not None else None, )
 
         result, n_outputs = _parameterrun_mpi(fun, formatted_param_names, formatted_param_values, desc,
-                                              pbar_bool=pbar_bool, verbose=verbose, **kwargs)
+                                              pbar_bool=pbar_bool, pbar_leave=pbar_leave, verbose=verbose, **fun_kwargs)
 
     else:
         raise ValueError('Unknown backend')

parameterrun-0.4.1/tests/test_pbar_format.py

@@ -0,0 +1,106 @@
+"""Test progress bar format for joblib backend."""
+import re
+
+import numpy as np
+
+from parameterrun import parameterrun
+
+
+def capture_pbar_output(n_workers: int, n_x: int = 10, n_y: int = 50) -> str:
+    """
+    Run parameterrun and capture progress bar output.
+
+    Parameters
+    ----------
+    n_workers : int
+        Number of workers to use
+    n_x : int
+        Number of x values
+    n_y : int
+        Number of y values
+
+    Returns
+    -------
+    str
+        Captured progress bar output
+    """
+
+    def dummy_func(x, y):
+        """Simple dummy function with two grouped parameters."""
+        return x + y
+
+    xs = np.linspace(0, 10, n_x)
+    ys = np.linspace(0, 20, n_y)
+
+    # Use StringIO to capture stderr (where tqdm writes progress bars)
+    import sys
+    from io import StringIO
+    old_stderr = sys.stderr
+    sys.stderr = StringIO()
+
+    try:
+        parameterrun(dummy_func, param_names=[["x"], ["y"]], param_values=[[xs], [ys]], n_workers=n_workers,
+                     pbar_bool=True, backend="joblib", pbar_leave=True,  # Keep the progress bar output for inspection
+                     )
+        output = sys.stderr.getvalue()
+    finally:
+        sys.stderr = old_stderr
+
+    return output
+
+
+def test_pbar_format_single_worker():
+    """Test progress bar format with n_workers=1."""
+    output = capture_pbar_output(n_workers=1, n_x=10, n_y=50)
+
+    # The format should contain:
+    # - Total count with progress: X/500 (e.g., "350/500" meaning 350/500 iterations)
+    # - Elapsed time: [MM:SS or HH:MM:SS]
+    # - Remaining time: <MM:SS or <HH:MM:SS
+    # - Rate: XX.XXit/s or YY.YYit/s
+
+    # Expected format: f: [['x'], ['y']]:   0%|          | 350/500 [00:17<7:05:24, 19.58it/s]
+
+    # Check for presence of total count pattern (e.g., "500/500" at completion)
+    print(output)
+    assert re.search(r'\d+/500', output), f"Progress bar missing total count pattern. Output: {output}"
+
+    # Check for remaining time pattern (e.g., "<MM:SS" or "<HH:MM:SS")
+    assert re.search(r'<\d+:\d{2}:\d{2}|<\d+:\d{2}',
+                     output), f"Progress bar missing remaining time pattern. Output: {output}"
+
+    # Check for rate pattern (XX.XXit/s or YY.YYit/s)
+    assert re.search(r'\d+\.\d+it/s|\d+\.\d+s/it', output), f"Progress bar missing rate pattern. Output: {output}"
+
+
+def test_pbar_format_multiple_workers():
+    """Test progress bar format with n_workers=2."""
+    output = capture_pbar_output(n_workers=2, n_x=10, n_y=50)
+
+    # The format should be the same for multi-worker case
+    # Expected format: f: [['x'], ['y']]:   0%|          | 350/500 [00:17<7:05:24, 19.58it/s]
+
+    # Check for presence of total count pattern (e.g., "500/500" at completion)
+    assert re.search(r'\d+/500', output), f"Progress bar missing total count pattern. Output: {output}"
+
+    # Check for remaining time pattern (e.g., "<MM:SS" or "<HH:MM:SS")
+    assert re.search(r'<\d+:\d{2}:\d{2}|<\d+:\d{2}',
+                     output), f"Progress bar missing remaining time pattern. Output: {output}"
+
+    # Check for rate pattern (XX.XXit/s or YY.YYit/s)
+    assert re.search(r'\d+\.\d+it/s|\d+\.\d+s/it', output), f"Progress bar missing rate pattern. Output: {output}"
+
+
+def test_pbar_does_not_have_incorrect_format():
+    """Test that progress bar does NOT use the incorrect format."""
+    output = capture_pbar_output(n_workers=1, n_x=5, n_y=10)
+
+    # Incorrect format would look like: "35it [00:03,  9.75it/s]"
+    # which has no total count or remaining time
+
+    # Check that we DON'T have the incorrect pattern
+    # The incorrect pattern is: digit(s) + "it [" with no "/" before
+    incorrect_pattern = r'(?<![/\d])\d+it \['
+
+    assert not re.search(incorrect_pattern,
+                         output), f"Progress bar has incorrect format (missing total count). Output: {output}"