parameterrun 0.3.0__tar.gz → 0.4.1__tar.gz

parameterrun-0.4.1/.github/workflows/ci.yml

@@ -0,0 +1,65 @@
+name: CI
+
+on:
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: non-mpi / ${{ matrix.os }} / py${{ matrix.python-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest, macos-latest, windows-latest ]
+        python-version: [ "3.9", "3.10", "3.11", "3.12", "3.13" ]
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install uv
+        run: python -m pip install uv
+
+      - name: Sync environment
+        run: uv sync
+
+      - name: Tests
+        run: uv run pytest -m "not mpi"
+
+      - name: Lint
+        run: uv run ruff check .
+
+      - name: Type check
+        run: uv run mypy
+
+  test-mpi-linux:
+    name: mpi / ubuntu-latest / py3.12 / 4 ranks
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Setup MPI
+        uses: mpi4py/setup-mpi@v1
+        with:
+          mpi: 'openmpi'
+
+      - name: Install uv
+        run: python -m pip install uv
+
+      - name: Sync environment with MPI extra
+        run: uv sync --extra mpi
+
+      - name: MPI tests (4 ranks)
+        run: mpirun -n 4 uv run pytest -m mpi -o addopts="-q -m mpi"

{parameterrun-0.3.0 → parameterrun-0.4.1}/.github/workflows/publish.yml

@@ -19,7 +19,7 @@ jobs:
         with:
           ref: ${{ github.event.workflow_run.head_sha }}
 
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.9"
 

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

@@ -4,22 +4,32 @@ All notable changes to this project are documented in this file.
 
 The format is based on Keep a Changelog and the project follows Semantic Versioning.
 
-## [0.3.1] - 2026-04-01
+## [Unreleased]
 
-### Added
-- (Your changes here)
+## [0.4.1] - 2026-04-21
 
-## [0.3.0] - 2026-04-01
+### 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
-- (Your changes here)
 
-## [0.3.0] - 2026-04-01
+- Added a test for the progress bar display when running with `backend="joblib"`.
+
+## [0.4.0] - 2026-04-21
 
 ### Added
-- (Your changes here)
 
-## [Unreleased]
+- Added `tests/test_mpi_integration.py` with MPI numerical-equivalence coverage for `parameterrun(..., backend="mpi")`.
+- Added a dedicated Linux PR CI job that runs MPI tests with 4 ranks.
+
+### Changed
+
+- Updated default test commands in docs and CI to run non-MPI tests with `-m "not mpi"`.
+- Registered a pytest `mpi` marker in `pyproject.toml` for explicit MPI test selection.
+- Update how the indices to compute are shared among workers. Previously, all the indices where computed by all workers,
+  which caused a significan overhead in the memory usage. Now, the indices are computed on the fly.
 
 ## [0.3.0] - 2026-04-01
 

{parameterrun-0.3.0 → parameterrun-0.4.1}/CONTRIBUTING.md

@@ -13,13 +13,22 @@ If you do not use `uv`, create a virtual environment and install equivalent dev
 ## Run quality checks
 
 ```bash
-uv run pytest
+uv run pytest -m "not mpi"
 uv run ruff check .
 uv run mypy
 uv run python -m build
 uv run python -m twine check dist/*
 ```
 
+## Run MPI checks (required on PR CI)
+
+The PR workflow includes a dedicated Linux MPI job that runs with 4 ranks.
+
+```bash
+uv sync --extra mpi
+mpirun -n 4 uv run pytest -m mpi -o addopts="-q -m mpi"
+```
+
 ## Pull request guidelines
 
 - Keep PRs focused and small when possible.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parameterrun
-Version: 0.3.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
@@ -210,12 +210,6 @@ By default, progress bars are enabled:
 result = parameterrun(my_function, param_names="x", param_values=[1, 2, 3], pbar_bool=True, )
 ```
 
-You can also pass extra keyword arguments to `tqdm` through `pbar_kwargs`:
-
-```python
-result = parameterrun(my_function, param_names="x", param_values=[1, 2, 3], pbar_kwargs={"leave": False}, )
-```
-
 Verbose logging can be enabled with:
 
 ```python
@@ -279,9 +273,17 @@ param_values = [[[1, 2], [10, 20]], [[100, 200, 300]], ]
 Before opening a PR or publishing a release, run:
 
 ```bash
-pytest
+pytest -m "not mpi"
 ruff check .
-mypy src/parameterrun
+mypy
 python -m build
 python -m twine check dist/*
 ```
+
+For MPI numerical-equivalence checks (Linux/OpenMPI, 4 ranks):
+
+```bash
+uv sync --extra mpi
+mpirun -n 4 uv run pytest -m mpi -o addopts="-q -m mpi"
+```
+

{parameterrun-0.3.0 → parameterrun-0.4.1}/README.md

@@ -178,12 +178,6 @@ By default, progress bars are enabled:
 result = parameterrun(my_function, param_names="x", param_values=[1, 2, 3], pbar_bool=True, )
 ```
 
-You can also pass extra keyword arguments to `tqdm` through `pbar_kwargs`:
-
-```python
-result = parameterrun(my_function, param_names="x", param_values=[1, 2, 3], pbar_kwargs={"leave": False}, )
-```
-
 Verbose logging can be enabled with:
 
 ```python
@@ -247,9 +241,17 @@ param_values = [[[1, 2], [10, 20]], [[100, 200, 300]], ]
 Before opening a PR or publishing a release, run:
 
 ```bash
-pytest
+pytest -m "not mpi"
 ruff check .
-mypy src/parameterrun
+mypy
 python -m build
 python -m twine check dist/*
 ```
+
+For MPI numerical-equivalence checks (Linux/OpenMPI, 4 ranks):
+
+```bash
+uv sync --extra mpi
+mpirun -n 4 uv run pytest -m mpi -o addopts="-q -m mpi"
+```
+

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.1/examples/minimal_example_mpi.py

@@ -0,0 +1,21 @@
+import numpy as np
+from mpi4py import MPI
+
+from parameterrun import parameterrun
+
+
+def f(x, y, scale=1):
+    return scale * (x + y)
+
+
+comm = MPI.COMM_WORLD
+rank = comm.Get_rank()
+size = comm.Get_size()
+
+xs = np.linspace(0, 10, 100)
+ys = np.linspace(0, 20, 50)
+
+result = parameterrun(f, param_names=[["x"], ["y"]], param_values=[[xs], [ys]], scale=2, backend='mpi')
+
+if rank == 0:
+    print(np.all(result == 2 * (xs[:, None] + ys[None, :])))

{parameterrun-0.3.0 → parameterrun-0.4.1}/pyproject.toml

@@ -64,6 +64,9 @@ packages = ["src/parameterrun"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-q --cov=parameterrun --cov-report=term-missing --cov-fail-under=70"
+markers = [
+    "mpi: tests that require mpi4py and an MPI launcher",
+]
 
 [tool.ruff]
 target-version = "py39"

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

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

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

@@ -4,6 +4,7 @@ import sys
 from collections.abc import Iterable
 from datetime import datetime
 from itertools import product
+from math import prod
 from time import time
 from typing import Any, Callable, List, Optional, Tuple, Union, cast
 
@@ -58,19 +59,18 @@ def tqdm_joblib(tqdm_object: tqdm):
 
 
 def _parameterrun_joblib(fun: Callable[..., Any], param_names: List[List[str]], param_values: List[List[List]],
-                         indices_iterate: list, desc, n_workers: Optional[int] = -1, pbar_bool: bool = True,
-                         leave: Optional[bool] = True, **fun_kwargs) -> Tuple[List[List], int]:
-    n_total = len(indices_iterate)
-    if n_total == 0:
-        raise ValueError('No parameter combinations generated. Please provide at least one value per group.')
+                         indices_iterate: Iterable, desc, n_workers: Optional[int] = -1, pbar_bool: bool = True,
+                         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)
@@ -86,9 +86,19 @@ def _parameterrun_joblib(fun: Callable[..., Any], param_names: List[List[str]],
     return result_temp, n_output
 
 
+def _product_element_from_index(lists: List[Any], k: int) -> List:
+    lengths = [len(L) for L in lists]
+
+    indices = [0] * len(lists)
+    for i in range(len(lists) - 1, -1, -1):
+        k, indices[i] = divmod(k, lengths[i])
+
+    return list(L[j] for L, j in zip(lists, indices))
+
+
 def _parameterrun_mpi(fun: Callable[..., Any], param_names: List[List[str]], param_values: List[List[List]],
-                      groups_iterate: list, desc: Optional[str], pbar_bool: bool = True,
-                      verbose: Optional[bool] = False, leave: Optional[bool] = True, **fun_kwargs) -> Tuple[
+                      desc: Optional[str], pbar_bool: bool = True, verbose: Optional[bool] = False,
+                      pbar_leave: Optional[bool] = True, seed=None, **fun_kwargs) -> Tuple[
     List[List], int]:  # pragma: no cover
     from mpi4py import MPI
 
@@ -96,21 +106,26 @@ def _parameterrun_mpi(fun: Callable[..., Any], param_names: List[List[str]], par
     rank = comm.Get_rank()
     size = comm.Get_size()
 
-    n_total = len(groups_iterate)
+    n_values = [len(group[0]) for group in param_values]
+    indices = [list(range(n_value)) for n_value in n_values]
+    n_total = prod(n_values)  # Compute the total number of iterations
 
     # Shuffle the indices to avoid bias in the computation
     if rank == 0:
+        rng = np.random.default_rng(seed=seed)
         total_indices = np.arange(n_total)
-        np.random.shuffle(total_indices)
+        rng.shuffle(total_indices)
     else:
         total_indices = None
 
     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] = []
@@ -144,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):
@@ -158,7 +174,7 @@ def _parameterrun_mpi(fun: Callable[..., Any], param_names: List[List[str]], par
 
         pbar.close()
     else:
-        comm.send(1, dest=0, tag=0)  # Notify root that the work is done
+        comm.send(True, dest=0, tag=0)  # Notify root that the work is done
 
     n_outputs = comm.bcast(n_outputs, root=0)
 
@@ -174,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
@@ -326,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: Optional[bool] = True, result_as_array: Optional[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
@@ -361,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)
@@ -373,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
@@ -386,16 +406,13 @@ 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]
     if any(n_value == 0 for n_value in n_values):
         raise ValueError('Parameter groups must contain at least one value.')
 
-    indices = [list(range(n_value)) for n_value in n_values]
-    indices_iterate = product(*indices)
-
     # Choose the backed
     if backend is not None:
         available_backends = ['joblib', 'mpi']
@@ -437,16 +454,18 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
     if backend == 'joblib':
         _log('Running under joblib', verbose)
 
-        result, n_outputs = _parameterrun_joblib(fun, formatted_param_names, formatted_param_values,
-                                                 list(indices_iterate), desc, n_workers=n_workers, pbar_bool=pbar_bool,
-                                                 **kwargs)
+        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, 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, list(indices_iterate),
-                                              desc, pbar_bool=pbar_bool, verbose=verbose, **kwargs)
+        result, n_outputs = _parameterrun_mpi(fun, formatted_param_names, formatted_param_values, desc,
+                                              pbar_bool=pbar_bool, pbar_leave=pbar_leave, verbose=verbose, **fun_kwargs)
 
     else:
         raise ValueError('Unknown backend')

parameterrun-0.4.1/tests/test_mpi_integration.py

@@ -0,0 +1,30 @@
+import numpy as np
+import pytest
+
+import parameterrun.parallel_utils as pu
+
+
+@pytest.mark.mpi
+def test_parameterrun_mpi_numerical_equivalence_and_root_return():
+    MPI = pytest.importorskip("mpi4py.MPI")
+    comm = MPI.COMM_WORLD
+
+    if comm.Get_size() != 4:
+        pytest.skip("Run this test with mpirun -n 4")
+
+    xs = np.array([0.0, 1.0, 2.0])
+    ys = np.array([10.0, 20.0])
+
+    def f(x, y, scale=1.0):
+        return scale * (x + y)
+
+    result = pu.parameterrun(f, param_names=[["x"], ["y"]], param_values=[[xs], [ys]], scale=2.0, backend="mpi",
+                             pbar_bool=False, )
+
+    expected = 2.0 * (xs[:, None] + ys[None, :])
+
+    if comm.Get_rank() == 0:
+        assert isinstance(result, np.ndarray)
+        np.testing.assert_allclose(result, expected)
+    else:
+        assert result is None

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}"

parameterrun-0.3.0/.github/workflows/ci.yml

@@ -1,40 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    branches: [ main ]
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    name: ${{ matrix.os }} / py${{ matrix.python-version }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ ubuntu-latest, macos-latest, windows-latest ]
-        python-version: [ "3.9", "3.10", "3.11", "3.12", "3.13" ]
-
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install uv
-        run: python -m pip install uv
-
-      - name: Sync environment
-        run: uv sync
-
-      - name: Tests
-        run: uv run pytest
-
-      - name: Lint
-        run: uv run ruff check .
-
-      - name: Type check
-        run: uv run mypy