parameterrun 0.2.1__tar.gz → 0.4.0__tar.gz

parameterrun-0.4.0/.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.2.1 → parameterrun-0.4.0}/.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.2.1 → parameterrun-0.4.0}/CHANGELOG.md

@@ -6,6 +6,30 @@ The format is based on Keep a Changelog and the project follows Semantic Version
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-04-21
+
+### Added
+
+- 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
+
+### Changed
+
+- Added `result_as_array` to `parameterrun(...)`: outputs are numpy arrays by default and can be converted to Python
+  lists with `result_as_array=False`.
+- Removed the `pbar_kwargs` optional argument from `parameterrun(...)`, as it was unused.
+- Added more tests for the depth of the parameter grid.
+- Added the possibility to add parameter values as numpy arrays, which are converted to lists internally.
+
 ## [0.2.1] - 2026-04-01
 
 ### Added

{parameterrun-0.2.1 → parameterrun-0.4.0}/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 src/parameterrun
+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.2.1 → parameterrun-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parameterrun
-Version: 0.2.1
+Version: 0.4.0
 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
@@ -146,9 +146,16 @@ print(mean_like)
 # array([2, 3, 4])
 
 print(square_like)  # array([1, 4, 9])
+
+# Ask for plain Python lists instead of numpy arrays
+mean_like, square_like = parameterrun(stats, param_names="x", param_values=[1, 2, 3], n_workers=1,
+                                      result_as_array=False, )
+
+print(mean_like)  # [2, 3, 4]
 ```
 
 If the function returns a single object, the result is returned as a single array when reshaping is possible.
+Set `result_as_array=False` to convert outputs to Python lists.
 
 For multi-dimensional sweeps, reshaping is automatic when `reshape=True` (default): the first dimensions always match
 the parameter grid shape.
@@ -203,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
@@ -223,18 +224,18 @@ The progress-bar description is generated automatically from the function name a
 `parameterrun`
 
 ```python
-parameterrun(fun, param_names, param_values, n_workers=-1, pbar_bool=True, verbose=False, pbar_kwargs=None,
-             reshape=True, backend=None, desc=None, **kwargs, )
+parameterrun(fun, param_names, param_values, n_workers=-1, pbar_bool=True, verbose=False,
+             reshape=True, result_as_array=True, backend=None, desc=None, **kwargs, )
 ```
 
 * `fun`: function to evaluate
 * `param_names`: parameter name or grouped parameter names
-* `param_values`: values corresponding to `param_names`
+* `param_values`: values corresponding to `param_names` (any iterable, e.g. list, tuple, range, numpy array)
 * `n_workers`: number of workers for `joblib`
 * `pbar_bool`: enable or disable progress bars
 * `verbose`: print backend and timing information
-* `pbar_kwargs`: additional keyword arguments passed to tqdm
 * `reshape`: reshape results into arrays when possible
+* `result_as_array`: return numpy arrays by default; if `False`, convert outputs to Python lists
 * `backend`: `"joblib"`, `"mpi"`, or `None`
 * `desc`: custom progress-bar label
 * `**kwargs`: extra fixed keyword arguments forwarded to `fun`
@@ -243,6 +244,9 @@ parameterrun(fun, param_names, param_values, n_workers=-1, pbar_bool=True, verbo
 
 `parameterrun` accepts three input styles.
 
+At every style, value containers can be any iterable (for example lists, tuples, ranges, generators, or numpy
+arrays).
+
 ### A. Single parameter
 
 ```python
@@ -269,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.2.1 → parameterrun-0.4.0}/README.md

@@ -114,9 +114,16 @@ print(mean_like)
 # array([2, 3, 4])
 
 print(square_like)  # array([1, 4, 9])
+
+# Ask for plain Python lists instead of numpy arrays
+mean_like, square_like = parameterrun(stats, param_names="x", param_values=[1, 2, 3], n_workers=1,
+                                      result_as_array=False, )
+
+print(mean_like)  # [2, 3, 4]
 ```
 
 If the function returns a single object, the result is returned as a single array when reshaping is possible.
+Set `result_as_array=False` to convert outputs to Python lists.
 
 For multi-dimensional sweeps, reshaping is automatic when `reshape=True` (default): the first dimensions always match
 the parameter grid shape.
@@ -171,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
@@ -191,18 +192,18 @@ The progress-bar description is generated automatically from the function name a
 `parameterrun`
 
 ```python
-parameterrun(fun, param_names, param_values, n_workers=-1, pbar_bool=True, verbose=False, pbar_kwargs=None,
-             reshape=True, backend=None, desc=None, **kwargs, )
+parameterrun(fun, param_names, param_values, n_workers=-1, pbar_bool=True, verbose=False,
+             reshape=True, result_as_array=True, backend=None, desc=None, **kwargs, )
 ```
 
 * `fun`: function to evaluate
 * `param_names`: parameter name or grouped parameter names
-* `param_values`: values corresponding to `param_names`
+* `param_values`: values corresponding to `param_names` (any iterable, e.g. list, tuple, range, numpy array)
 * `n_workers`: number of workers for `joblib`
 * `pbar_bool`: enable or disable progress bars
 * `verbose`: print backend and timing information
-* `pbar_kwargs`: additional keyword arguments passed to tqdm
 * `reshape`: reshape results into arrays when possible
+* `result_as_array`: return numpy arrays by default; if `False`, convert outputs to Python lists
 * `backend`: `"joblib"`, `"mpi"`, or `None`
 * `desc`: custom progress-bar label
 * `**kwargs`: extra fixed keyword arguments forwarded to `fun`
@@ -211,6 +212,9 @@ parameterrun(fun, param_names, param_values, n_workers=-1, pbar_bool=True, verbo
 
 `parameterrun` accepts three input styles.
 
+At every style, value containers can be any iterable (for example lists, tuples, ranges, generators, or numpy
+arrays).
+
 ### A. Single parameter
 
 ```python
@@ -237,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.2.1 → parameterrun-0.4.0}/examples/minimal_example.py

@@ -11,4 +11,3 @@ xs = np.linspace(0, 10, 100)
 ys = np.linspace(0, 20, 50)
 
 result = parameterrun(f, param_names=[["x"], ["y"]], param_values=[[xs], [ys]], n_workers=1, scale=2, )
-result = result.reshape(len(xs), len(ys))

parameterrun-0.4.0/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.2.1 → parameterrun-0.4.0}/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.2.1 → parameterrun-0.4.0}/src/parameterrun/__init__.py

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

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

@@ -1,10 +1,12 @@
 import contextlib
 import inspect
 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
+from typing import Any, Callable, List, Optional, Tuple, Union, cast
 
 import joblib
 import numpy as np
@@ -57,14 +59,10 @@ 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,
+                         indices_iterate: Iterable, 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.')
-
+    result = []
     if n_workers == 1:  # If only one worker, do not use joblib
-        result = []
         pbar = tqdm(indices_iterate, desc=desc, leave=leave, disable=not pbar_bool)
         for index in pbar:
             result.append(fun(**{**_get_iteration(index, param_names, param_values), **fun_kwargs}))
@@ -74,6 +72,8 @@ def _parameterrun_joblib(fun: Callable[..., Any], param_names: List[List[str]],
                 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]
@@ -85,28 +85,45 @@ 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: str, pbar_bool: bool = True, verbose: Optional[bool] = False,
-                      leave: Optional[bool] = True, **fun_kwargs) -> Tuple[List[List], int]:  # pragma: no cover
+                      desc: Optional[str], pbar_bool: bool = True, verbose: Optional[bool] = False,
+                      leave: Optional[bool] = True, seed=None, **fun_kwargs) -> Tuple[
+    List[List], int]:  # pragma: no cover
     from mpi4py import MPI
 
     comm = MPI.COMM_WORLD
     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 = 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)
 
@@ -156,7 +173,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)
 
@@ -202,6 +219,12 @@ def _flatten_param_names(param_names: List[List[str]]) -> List[str]:
     return [name for group in param_names for name in group]
 
 
+def _to_list_iterable(values: Any, error_message: str) -> List[Any]:
+    if isinstance(values, (str, bytes)) or not isinstance(values, Iterable):
+        raise ValueError(error_message)
+    return list(values)
+
+
 def _validate_function_arguments(fun: Callable[..., Any], param_names: List[List[str]], fun_kwargs: dict) -> None:
     signature = inspect.signature(fun)
     parameters = signature.parameters
@@ -231,21 +254,18 @@ def _validate_function_arguments(fun: Callable[..., Any], param_names: List[List
         raise ValueError(f'Unknown keyword arguments for function {fun.__name__}: {unknown_kwargs}')
 
 
-def _format_input(param_names: Union[str, list], param_values: list) -> Tuple[List[List[str]], List[List[List]]]:
+def _format_input(param_names: Union[str, List[str], List[List[str]]], param_values: Any) -> Tuple[
+    List[List[str]], List[List[List[Any]]]]:
     # Check the depth of the parameters
 
     if isinstance(param_names, str):
         if not param_names:
             raise ValueError('Parameter names must be non-empty strings')
-        if not isinstance(param_values, list):
-            raise ValueError('The parameters values must be a list of values')
         depth = 1
     elif isinstance(param_names, list) and len(param_names) > 0 and all(isinstance(name, str) for name in param_names):
         if any(not name for name in param_names):
             raise ValueError('Parameter names must be non-empty strings')
         depth = 2
-        if not isinstance(param_values, list):
-            raise ValueError('The parameters values must be a list of values')
     elif isinstance(param_names, list) and len(param_names) > 0 and all(
             isinstance(group, list) for group in param_names):
         if any(len(group) == 0 for group in param_names):
@@ -253,44 +273,53 @@ def _format_input(param_names: Union[str, list], param_values: list) -> Tuple[Li
         if any(any(not isinstance(name, str) or not name for name in group) for group in param_names):
             raise ValueError('Parameter names must be non-empty strings')
         depth = 3
-        if not isinstance(param_values, list) or len(param_values) == 0 or not isinstance(param_values[0], list):
-            raise ValueError('The parameters values must be a list of values')
     else:
         raise ValueError('Unknown input format for the parameters names')
 
+    normalized_param_names: List[List[str]]
+    normalized_param_values: List[List[List[Any]]]
+
     # Correct the input if the depth is not equal to 3
     if depth == 1:
         # Only one parameter is provided
-        param_names = [[param_names]]
-        param_values = [[param_values]]
+        values = _to_list_iterable(param_values, 'The parameters values must be an iterable of values')
+        normalized_param_names = [[cast(str, param_names)]]
+        normalized_param_values = [[values]]
     elif depth == 2:
         # Groups with a single parameters are provided
-        param_names = [[param_name_i] for param_name_i in param_names]
-        param_values = [[param_values_i] for param_values_i in param_values]
+        values = _to_list_iterable(param_values, 'The parameters values must be an iterable of values')
+        normalized_param_names = [[param_name_i] for param_name_i in cast(List[str], param_names)]
+        normalized_param_values = [
+            [_to_list_iterable(param_values_i, 'Each parameter values entry must be an iterable')] for param_values_i in
+            values]
+    else:
+        groups_values = _to_list_iterable(param_values, 'The parameters values must be an iterable of values')
+        groups_values = [_to_list_iterable(values_group, 'Each parameter group values must be provided as an iterable')
+                         for values_group in groups_values]
+        normalized_param_names = cast(List[List[str]], param_names)
+        normalized_param_values = [
+            [_to_list_iterable(parameter_values, 'Each parameter values entry must be an iterable') for parameter_values
+             in values_group] for values_group in groups_values]
 
     # Check that the number of groups of parameters is the same as the number of groups of values
-    if len(param_names) != len(param_values):
+    if len(normalized_param_names) != len(normalized_param_values):
         raise ValueError('The number of groups of parameters must be the same as the number of groups of values')
 
-    for names_group, values_group in zip(param_names, param_values):
-        if not isinstance(values_group, list):
-            raise ValueError('Each parameter group values must be provided as a list')
+    for names_group, values_group in zip(normalized_param_names, normalized_param_values):
         if len(names_group) != len(values_group):
             raise ValueError('Each parameter group must include one values list per parameter')
-        if any(not isinstance(parameter_values, list) for parameter_values in values_group):
-            raise ValueError('Each parameter values entry must be a list')
 
     # Check that all parameters in the same group have the same length
-    for group in param_values:
+    for group in normalized_param_values:
         if len(set([len(param) for param in group])) != 1:
             raise ValueError('All parameters in the same group must have the same length')
 
-    all_names = _flatten_param_names(param_names)  # type: ignore[arg-type]
+    all_names = _flatten_param_names(normalized_param_names)
     duplicated = sorted({name for name in all_names if all_names.count(name) > 1})
     if duplicated:
         raise ValueError(f'Duplicate parameter names are not allowed: {duplicated}')
 
-    return param_names, param_values  # type: ignore[return-value]
+    return normalized_param_names, normalized_param_values
 
 
 def _reshape_channel_result(channel_values: List[Any], n_values: List[int]) -> np.ndarray:
@@ -302,11 +331,19 @@ def _reshape_channel_result(channel_values: List[Any], n_values: List[int]) -> n
     return array_result.reshape(target_shape)
 
 
+def _convert_result_to_lists(result: Any) -> Any:
+    if isinstance(result, np.ndarray):
+        return result.tolist()
+    if isinstance(result, list):
+        return [_convert_result_to_lists(item) for item in result]
+    return result
+
+
 def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], List[List[str]]],
-                 param_values: Union[List, List[List], List[List[List]]], n_workers: Optional[int] = -1,
-                 pbar_bool: bool = True, verbose: Optional[bool] = False, pbar_kwargs: Optional[dict] = None,
-                 reshape: Optional[bool] = True, backend: Optional[str] = None, desc: Optional[str] = None, **kwargs) -> \
-        Union[list, np.ndarray, None]:  # noqa: E501
+                 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
     """
     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
@@ -332,8 +369,9 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
         Function to run in parallel.
     param_names : str or list
         Name of the parameters to run in parallel.
-    param_values : list
-        Values of the parameters to run in parallel.
+    param_values : iterable
+        Values of the parameters to run in parallel. Lists, tuples, ranges, generators, and numpy arrays are
+        accepted as long as they follow one of the supported input shapes.
     n_workers : int, optional (default=-1)
         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)
@@ -342,11 +380,12 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
         Backend to use for the parallelization. If None, the backend is chosen automatically between joblib and mpi.
     verbose : bool, optional (default=False)
         If True, print information about the parallelization.
-    pbar_kwargs : dict, optional (default=None)
-        Dictionary with the parameters to pass to the tqdm such as desc and leave.
     reshape : bool, optional (default=True)
         If True, reshape the result as a (hyper)matrix. Sometimes, due to the nature of the output, the reshape is not
         possible, in this case, the result is not reshaped.
+    result_as_array : bool, optional (default=True)
+        If True, return numpy arrays when possible (default behavior). If False, convert numpy-array outputs to Python
+        lists.
     desc: str, optional (default=None)
         Description of the progress bar. If None, the description denotes the function and parameters names.
     kwargs :
@@ -359,22 +398,16 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
          n_valuesN), where n_valuesI is the number of values in the I-th group.
     """
 
-    if pbar_kwargs is None:
-        pbar_kwargs = {}
-
     time_start = time()
 
-    param_names, param_values = _format_input(param_names, param_values)
-    _validate_function_arguments(fun, param_names, kwargs)
+    formatted_param_names, formatted_param_values = _format_input(param_names, param_values)
+    _validate_function_arguments(fun, formatted_param_names, kwargs)
 
     # Create the list of dictionaries with the parameters in a nested loop
-    n_values = [len(group[0]) for group in param_values]
+    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']
@@ -402,43 +435,54 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
             backend = 'mpi'
 
     if desc is None:
-        param_names_pbar = [parameters_names_i for parameters_names_i in param_names]
-        desc = f'{fun.__name__}: {param_names_pbar}'
+        param_names_pbar = [parameters_names_i for parameters_names_i in formatted_param_names]
+        auto_desc = f'{fun.__name__}: {param_names_pbar}'
+
+        if len(auto_desc) > 40:
+            auto_desc = auto_desc[:40] + '(...)]'
 
-        if len(desc) > 40:
-            desc = desc[:40] + '(...)'
+        desc = auto_desc
 
     # Execute the parallel run
+    result: List[List[Any]]
+
     if backend == 'joblib':
         _log('Running under joblib', verbose)
 
-        result, n_outputs = _parameterrun_joblib(fun, param_names, param_values, list(indices_iterate), desc,
-                                                 n_workers=n_workers, pbar_bool=pbar_bool, **pbar_kwargs, **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, **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, param_names, param_values, list(indices_iterate), desc,
-                                              pbar_bool=pbar_bool, verbose=verbose, **pbar_kwargs, **kwargs)
+        result, n_outputs = _parameterrun_mpi(fun, formatted_param_names, formatted_param_values, desc,
+                                              pbar_bool=pbar_bool, verbose=verbose, **kwargs)
 
     else:
         raise ValueError('Unknown backend')
 
     if rank == 0:
+        final_result: Union[List[List[Any]], np.ndarray, List[np.ndarray]] = result
+
         # Reshape the result to get the (hyper)matrix
         if reshape:
             try:
                 if n_outputs == 1:
-                    result = _reshape_channel_result(result[0], n_values)
+                    final_result = _reshape_channel_result(result[0], n_values)
                 else:
-                    result = [_reshape_channel_result(result[i], n_values) for i in range(n_outputs)]
+                    final_result = [_reshape_channel_result(result[i], n_values) for i in range(n_outputs)]
             except ValueError:
                 print('Could not reshape the result')
 
         total_time = time() - time_start
         _log(f'Total time: {_normalized_time(total_time)}', verbose)
 
-        return result
+        if not result_as_array:
+            final_result = _convert_result_to_lists(final_result)
+
+        return final_result
     else:
         return None

parameterrun-0.4.0/tests/test_depths.py

@@ -0,0 +1,36 @@
+import numpy as np
+
+from parameterrun import parameterrun
+
+
+def test_depth_1():
+    def fun(x):
+        return x ** 2
+
+    xs = np.linspace(0, 10, 5)
+    result = parameterrun(fun, 'x', xs, n_workers=1, pbar_bool=False)
+
+    assert isinstance(result, np.ndarray)
+    np.testing.assert_array_equal(result, xs ** 2)
+
+
+def test_depth_2():
+    def fun(x):
+        return x ** 2
+
+    xs = np.linspace(0, 10, 5)
+    result = parameterrun(fun, ['x'], [xs], n_workers=1, pbar_bool=False)
+
+    assert isinstance(result, np.ndarray)
+    np.testing.assert_array_equal(result, xs ** 2)
+
+
+def test_depth_3():
+    def fun(x):
+        return x ** 2
+
+    xs = np.linspace(0, 10, 5)
+    result = parameterrun(fun, [['x']], [[xs]], n_workers=1, pbar_bool=False)
+
+    assert isinstance(result, np.ndarray)
+    np.testing.assert_array_equal(result, xs ** 2)

{parameterrun-0.2.1 → parameterrun-0.4.0}/tests/test_format_input.py

@@ -1,3 +1,4 @@
+import numpy as np
 import pytest
 
 from parameterrun.parallel_utils import _format_input
@@ -25,9 +26,27 @@ def test_format_input_rejects_empty_parameter_name():
         _format_input("", [1, 2])
 
 
-def test_format_input_rejects_non_list_group_values():
-    with pytest.raises(ValueError, match="values entry must be a list"):
-        _format_input([["x"]], [[(1, 2)]])
+def test_format_input_accepts_numpy_array_values():
+    names, values = _format_input("x", np.array([1, 2, 3]))
+    assert names == [["x"]]
+    assert values == [[[1, 2, 3]]]
+
+
+def test_format_input_accepts_iterables_in_multiple_parameter_format():
+    names, values = _format_input(["x", "y"], (range(3), (10, 20, 30)))
+    assert names == [["x"], ["y"]]
+    assert values == [[[0, 1, 2]], [[10, 20, 30]]]
+
+
+def test_format_input_accepts_tuple_parameter_values_inside_group():
+    names, values = _format_input([["x"]], [[(1, 2)]])
+    assert names == [["x"]]
+    assert values == [[[1, 2]]]
+
+
+def test_format_input_rejects_string_values():
+    with pytest.raises(ValueError, match="iterable of values"):
+        _format_input("x", "123")
 
 
 def test_format_input_rejects_duplicate_names():

parameterrun-0.4.0/tests/test_joblib.py

@@ -0,0 +1,14 @@
+import numpy as np
+
+from parameterrun import parameterrun
+
+
+def test_joblib_2_workers():
+    def f(x):
+        return x ** 2
+
+    xs = np.linspace(0, 10, 5)
+    result = parameterrun(f, 'x', xs, n_workers=2, pbar_bool=False, backend="joblib")
+
+    assert isinstance(result, np.ndarray)
+    np.testing.assert_array_equal(result, xs ** 2)

parameterrun-0.4.0/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.2.1 → parameterrun-0.4.0}/tests/test_parameter_run.py

@@ -15,6 +15,17 @@ def test_parameterrun_single_parameter_returns_1d_array():
     np.testing.assert_array_equal(result, np.array([0, 1, 4, 9]))
 
 
+def test_parameterrun_single_parameter_can_return_list():
+    def square(x):
+        return x ** 2
+
+    result = pu.parameterrun(square, param_names="x", param_values=[0, 1, 2, 3], n_workers=1, pbar_bool=False,
+                             backend="joblib", result_as_array=False, )
+
+    assert isinstance(result, list)
+    assert result == [0, 1, 4, 9]
+
+
 def test_parameterrun_grouped_parameters_builds_expected_grid():
     def f(x, y, z, offset=0):
         return x + y + z + offset
@@ -47,6 +58,17 @@ def test_parameterrun_multiple_outputs_returns_list_of_arrays():
     np.testing.assert_array_equal(result[1], np.array([1, 4, 9]))
 
 
+def test_parameterrun_multiple_outputs_can_return_list_of_lists():
+    def f(x):
+        return x + 1, x ** 2
+
+    result = pu.parameterrun(f, param_names="x", param_values=[1, 2, 3], n_workers=1, pbar_bool=False,
+                             backend="joblib", result_as_array=False, )
+
+    assert isinstance(result, list)
+    assert result == [[2, 3, 4], [1, 4, 9]]
+
+
 def test_parameterrun_multiple_outputs_keep_grid_shape():
     def f(x, y):
         return x + y, x * y

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

@@ -1,48 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    branches: [ main ]
-  #  push:
-  #    branches: [ main ]
-  # Optional only if you use GitHub merge queue:
-  # merge_group:
-  #   types: [checks_requested]
-
-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: Lint
-        run: uv run ruff check .
-
-      # - name: Format check
-      #   run: uv run ruff format --check .
-
-      # - name: Type check
-      #   run: uv run mypy
-
-      - name: Tests
-        run: uv run pytest