parameterrun 0.1.0__tar.gz → 0.2.1__tar.gz

{parameterrun-0.1.0 → parameterrun-0.2.1}/.github/workflows/ci.yml

@@ -1,9 +1,16 @@
 name: CI
 
 on:
-  push:
-    branches: [ main ]
   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:
@@ -16,7 +23,7 @@ jobs:
         python-version: [ "3.9", "3.10", "3.11", "3.12", "3.13" ]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - uses: actions/setup-python@v5
         with:
@@ -31,33 +38,11 @@ jobs:
       - name: Lint
         run: uv run ruff check .
 
-#      - name: Format check
-#        run: uv run ruff format --check .
+      # - name: Format check
+      #   run: uv run ruff format --check .
 
-#      - name: Type check
-#        run: uv run mypy
+      # - name: Type check
+      #   run: uv run mypy
 
       - name: Tests
-        run: uv run pytest
-
-  build:
-    name: Build package
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.9"
-
-      - name: Install uv
-        run: python -m pip install uv
-
-      - name: Sync environment
-        run: uv sync
-
-      - name: Build
-        run: uv run python -m build
-
-      - name: Check distributions
-        run: uv run twine check --strict dist/*
+        run: uv run pytest

{parameterrun-0.1.0 → parameterrun-0.2.1}/.github/workflows/publish.yml

@@ -1,18 +1,23 @@
 name: Publish
 
 on:
-  push:
-    tags:
-      - "v0.1.0"
+  workflow_run:
+    workflows: ["Release"]
+    types: [completed]
 
 jobs:
-  build:
+  publish:
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
     runs-on: ubuntu-latest
+    environment: pypi
     permissions:
       contents: read
+      id-token: write
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event.workflow_run.head_sha }}
 
       - uses: actions/setup-python@v5
         with:
@@ -30,21 +35,5 @@ jobs:
       - name: Check distributions
         run: uv run twine check --strict dist/*
 
-      - uses: actions/upload-artifact@v4
-        with:
-          name: dist
-          path: dist/
-
-  publish:
-    needs: build
-    runs-on: ubuntu-latest
-    permissions:
-      id-token: write
-
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          name: dist
-          path: dist/
-
-      - uses: pypa/gh-action-pypi-publish@release/v1
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

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

@@ -0,0 +1,88 @@
+name: Release
+
+on:
+  push:
+    branches: [ main ]
+
+permissions:
+  contents: write
+
+concurrency:
+  group: release-main
+  cancel-in-progress: false
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: ${{ github.sha }}
+          fetch-depth: 0
+
+      - name: Read version from package
+        id: version
+        run: |
+          python - <<'PY'
+          import os
+          import pathlib
+          import re
+
+          init_file = pathlib.Path("src/parameterrun/__init__.py")
+          content = init_file.read_text(encoding="utf-8")
+          match = re.search(r'__version__\s*=\s*"([^"]+)"', content)
+          if not match:
+              raise SystemExit("Could not find __version__ in src/parameterrun/__init__.py")
+
+          version = match.group(1)
+          output_file = os.environ["GITHUB_OUTPUT"]
+          with open(output_file, "a", encoding="utf-8") as f:
+              f.write(f"version={version}\n")
+              f.write(f"tag=v{version}\n")
+          PY
+
+      - name: Fail if tag already exists
+        env:
+          TAG: ${{ steps.version.outputs.tag }}
+        run: |
+          git fetch --tags origin
+          if git ls-remote --exit-code --tags origin "refs/tags/${TAG}" >/dev/null 2>&1; then
+            echo "Tag ${TAG} already exists. Bump __version__ before merging to main."
+            exit 1
+          fi
+
+      - name: Extract release notes from changelog
+        env:
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          python - <<'PY'
+          import os
+          import pathlib
+          import re
+
+          version = os.environ["VERSION"]
+          changelog = pathlib.Path("CHANGELOG.md").read_text(encoding="utf-8")
+
+          pattern = re.compile(
+              rf"^## \[{re.escape(version)}\][^\n]*\n(?P<body>.*?)(?=^## \[|\Z)",
+              re.MULTILINE | re.DOTALL,
+          )
+          match = pattern.search(changelog)
+          if not match:
+              raise SystemExit(f"Could not find CHANGELOG entry for version {version}")
+
+          notes = match.group("body").strip()
+          pathlib.Path("release_notes.md").write_text(notes + "\n", encoding="utf-8")
+          PY
+
+      - name: Create GitHub release and tag
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ steps.version.outputs.tag }}
+          SHA: ${{ github.sha }}
+        run: |
+          gh release create "${TAG}" \
+            --target "${SHA}" \
+            --title "${TAG}" \
+            --notes-file release_notes.md

parameterrun-0.2.1/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+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.
+
+## [Unreleased]
+
+## [0.2.1] - 2026-04-01
+
+### Added
+
+- Modified GitHub Actions workflow to trigger on pull requests to the main branch, ensuring that all changes are
+  reviewed before merging.
+
+## [0.2.0] - 2026-03-26
+
+### Added
+
+- Automated version management: single source of truth in `src/parameterrun/__init__.py`
+- Version bump script `scripts/bump_version.py` for automatic version updates across all files
+- VERSIONING.md guide for release workflows and version management
+- `__version__` exported from main package: `from parameterrun import __version__`
+- Dynamic version extraction in `pyproject.toml` (no more manual version updates needed)
+
+### Changed
+
+- `parameterrun(..., reshape=True)` now reshapes outputs to the parameter-grid dimensions automatically (including
+  multi-output functions).
+- Added early validation for duplicate parameter names, unknown swept parameters, unknown kwargs, and kwarg/sweep-name
+  conflicts.
+
+## [0.1.0] - 2026-03-25
+
+### Added
+
+- Initial public release of `parameterrun`

{parameterrun-0.1.0 → parameterrun-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parameterrun
-Version: 0.1.0
+Version: 0.2.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
@@ -104,7 +104,6 @@ def f(x, y, scale=1):
 
 result = parameterrun(f, param_names=["x", "y"], param_values=[[1, 2, 3], [10, 20], ], scale=2, )
 
-result = result.reshape(3, 2)
 print(result.shape)  # (3, 2)
 ```
 
@@ -121,10 +120,9 @@ def f(x, y, z):
 
 
 result = parameterrun(f, param_names=[["x", "y"], ["z"]], param_values=[[[1, 2], [10, 20]],  # (x, y) = (1,10), (2,20)
-                                                                         [[100, 200, 300]],  # z varies independently
-                                                                         ], n_workers=1, )
+                                                                        [[100, 200, 300]],  # z varies independently
+                                                                        ], n_workers=1, )
 
-result = result.reshape(2, 3)
 print(result.shape)  # (2, 3)
 ```
 
@@ -152,6 +150,18 @@ print(square_like)  # array([1, 4, 9])
 
 If the function returns a single object, the result is returned as a single array when reshaping is possible.
 
+For multi-dimensional sweeps, reshaping is automatic when `reshape=True` (default): the first dimensions always match
+the parameter grid shape.
+
+## Validation behavior
+
+`parameterrun` validates inputs before launching workers and raises clear `ValueError`s when:
+
+- parameter names are duplicated
+- a swept parameter does not exist in the target function signature
+- extra keyword arguments do not match the target function signature
+- a keyword argument conflicts with a swept parameter name
+
 ## Parallel backend
 
 `parameterrun` supports two execution backends:
@@ -166,7 +176,7 @@ If `backend=None`, the package tries to detect whether MPI is available. If MPI
 
 ```python
 result = parameterrun(my_function, param_names=["x", "y"], param_values=[[1, 2, 3], [4, 5]], backend="joblib",
-    n_workers=-1, )
+                      n_workers=-1, )
 ```
 
 If `n_workers=1`, the function runs serially without spawning joblib workers.
@@ -214,7 +224,7 @@ The progress-bar description is generated automatically from the function name a
 
 ```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, )
+             reshape=True, backend=None, desc=None, **kwargs, )
 ```
 
 * `fun`: function to evaluate

{parameterrun-0.1.0 → parameterrun-0.2.1}/README.md

@@ -72,7 +72,6 @@ def f(x, y, scale=1):
 
 result = parameterrun(f, param_names=["x", "y"], param_values=[[1, 2, 3], [10, 20], ], scale=2, )
 
-result = result.reshape(3, 2)
 print(result.shape)  # (3, 2)
 ```
 
@@ -89,10 +88,9 @@ def f(x, y, z):
 
 
 result = parameterrun(f, param_names=[["x", "y"], ["z"]], param_values=[[[1, 2], [10, 20]],  # (x, y) = (1,10), (2,20)
-                                                                         [[100, 200, 300]],  # z varies independently
-                                                                         ], n_workers=1, )
+                                                                        [[100, 200, 300]],  # z varies independently
+                                                                        ], n_workers=1, )
 
-result = result.reshape(2, 3)
 print(result.shape)  # (2, 3)
 ```
 
@@ -120,6 +118,18 @@ print(square_like)  # array([1, 4, 9])
 
 If the function returns a single object, the result is returned as a single array when reshaping is possible.
 
+For multi-dimensional sweeps, reshaping is automatic when `reshape=True` (default): the first dimensions always match
+the parameter grid shape.
+
+## Validation behavior
+
+`parameterrun` validates inputs before launching workers and raises clear `ValueError`s when:
+
+- parameter names are duplicated
+- a swept parameter does not exist in the target function signature
+- extra keyword arguments do not match the target function signature
+- a keyword argument conflicts with a swept parameter name
+
 ## Parallel backend
 
 `parameterrun` supports two execution backends:
@@ -134,7 +144,7 @@ If `backend=None`, the package tries to detect whether MPI is available. If MPI
 
 ```python
 result = parameterrun(my_function, param_names=["x", "y"], param_values=[[1, 2, 3], [4, 5]], backend="joblib",
-    n_workers=-1, )
+                      n_workers=-1, )
 ```
 
 If `n_workers=1`, the function runs serially without spawning joblib workers.
@@ -182,7 +192,7 @@ The progress-bar description is generated automatically from the function name a
 
 ```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, )
+             reshape=True, backend=None, desc=None, **kwargs, )
 ```
 
 * `fun`: function to evaluate

{parameterrun-0.1.0 → parameterrun-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "parameterrun"
-version = "0.1.0"
+dynamic = ["version"]
 description = "Parallel parameter sweeps with joblib/MPI and tqdm progress bars."
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -54,6 +54,10 @@ dev = [
     "twine>=6",
 ]
 
+[tool.hatch.version]
+path = "src/parameterrun/__init__.py"
+pattern = '__version__ = "(?P<version>[^"]+)"'
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/parameterrun"]
 

parameterrun-0.2.1/scripts/bump_version.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+"""
+Script to automate version bumping across all project files.
+
+Usage:
+    python scripts/bump_version.py <new_version>
+    python scripts/bump_version.py --patch
+    python scripts/bump_version.py --minor
+    python scripts/bump_version.py --major
+
+Example:
+    python scripts/bump_version.py 0.2.0
+    python scripts/bump_version.py --minor  # bumps X.Y to X.Y+1
+"""
+
+import re
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Tuple
+
+
+def parse_version(version_str: str) -> Tuple[int, int, int]:
+    """Parse semantic version string into (major, minor, patch)."""
+    parts = version_str.split(".")
+    if len(parts) != 3:
+        raise ValueError(f"Invalid version format: {version_str}. Expected: X.Y.Z")
+    try:
+        major, minor, patch = (int(p) for p in parts)
+        return major, minor, patch
+    except ValueError as err:
+        raise ValueError(f"Version parts must be integers: {version_str}") from err
+
+
+def version_to_string(major: int, minor: int, patch: int) -> str:
+    """Convert (major, minor, patch) to string."""
+    return f"{major}.{minor}.{patch}"
+
+
+def bump_version(version_str: str, bump_type: str) -> str:
+    """Bump version based on type: 'major', 'minor', or 'patch'."""
+    major, minor, patch = parse_version(version_str)
+
+    if bump_type == "major":
+        major += 1
+        minor = 0
+        patch = 0
+    elif bump_type == "minor":
+        minor += 1
+        patch = 0
+    elif bump_type == "patch":
+        patch += 1
+    else:
+        raise ValueError(f"Unknown bump type: {bump_type}")
+
+    return version_to_string(major, minor, patch)
+
+
+def get_current_version(init_file: Path) -> str:
+    """Extract current version from __init__.py."""
+    content = init_file.read_text()
+    match = re.search(r'__version__\s*=\s*"([^"]+)"', content)
+    if not match:
+        raise ValueError(f"Could not find __version__ in {init_file}")
+    return match.group(1)
+
+
+def update_init_file(init_file: Path, new_version: str) -> None:
+    """Update version in __init__.py."""
+    content = init_file.read_text()
+    updated = re.sub(
+        r'__version__\s*=\s*"[^"]+"',
+        f'__version__ = "{new_version}"',
+        content
+    )
+    init_file.write_text(updated)
+    print(f"✓ Updated {init_file.relative_to(init_file.parent.parent.parent)}")
+
+
+def update_changelog(changelog_file: Path, new_version: str) -> None:
+    """Update CHANGELOG.md with new version section."""
+    content = changelog_file.read_text()
+
+    # Create new version entry
+    date = datetime.now().strftime("%Y-%m-%d")
+    new_entry = f"""## [{new_version}] - {date}
+
+### Added
+- (Your changes here)
+
+"""
+
+    # Replace [Unreleased] section with new version and restore [Unreleased]
+    updated = re.sub(
+        r"## \[Unreleased\]",
+        f"{new_entry}## [Unreleased]",
+        content
+    )
+
+    # If no changes were made, insert new version after the header
+    if updated == content:
+        lines = content.split("\n")
+        insert_idx = next(i for i, line in enumerate(lines) if line.startswith("## "))
+        lines.insert(insert_idx, new_entry.rstrip("\n"))
+        updated = "\n".join(lines)
+
+    changelog_file.write_text(updated)
+    print(f"✓ Updated {changelog_file.relative_to(changelog_file.parent.parent.parent)}")
+
+
+def main() -> None:
+    project_root = Path(__file__).parent.parent
+    init_file = project_root / "src" / "parameterrun" / "__init__.py"
+    changelog_file = project_root / "CHANGELOG.md"
+
+    # Parse arguments
+    if len(sys.argv) < 2:
+        print(__doc__)
+        sys.exit(1)
+
+    arg = sys.argv[1]
+
+    # Get current version
+    current_version = get_current_version(init_file)
+    print(f"Current version: {current_version}\n")
+
+    # Determine new version
+    if arg.startswith("--"):
+        bump_type = arg[2:]
+        if bump_type not in ["major", "minor", "patch"]:
+            print(f"Invalid bump type: {bump_type}")
+            sys.exit(1)
+        new_version = bump_version(current_version, bump_type)
+    else:
+        # Validate provided version format
+        new_version = arg
+        try:
+            parse_version(new_version)
+        except ValueError as e:
+            print(f"Error: {e}")
+            sys.exit(1)
+
+    print(f"New version: {new_version}\n")
+
+    # Update files
+    try:
+        update_init_file(init_file, new_version)
+        update_changelog(changelog_file, new_version)
+        print(f"\n✓ Version successfully bumped to {new_version}")
+        print("  Remember to: commit, tag, and push the changes")
+        print(f"  Example: git tag v{new_version}")
+    except Exception as e:
+        print(f"Error during update: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+

parameterrun-0.2.1/src/parameterrun/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.2.1"
+
+from .parallel_utils import parameterrun
+
+__all__ = ["parameterrun", "__version__"]

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

@@ -1,4 +1,5 @@
 import contextlib
+import inspect
 import sys
 from datetime import datetime
 from itertools import product
@@ -197,18 +198,62 @@ def _get_iteration(index, param_names, param_values):
     return dic_temp
 
 
+def _flatten_param_names(param_names: List[List[str]]) -> List[str]:
+    return [name for group in param_names for name in group]
+
+
+def _validate_function_arguments(fun: Callable[..., Any], param_names: List[List[str]], fun_kwargs: dict) -> None:
+    signature = inspect.signature(fun)
+    parameters = signature.parameters
+    accepts_var_kwargs = any(parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in parameters.values())
+
+    sweep_names = _flatten_param_names(param_names)
+
+    duplicated = sorted({name for name in sweep_names if sweep_names.count(name) > 1})
+    if duplicated:
+        raise ValueError(f'Duplicate parameter names are not allowed: {duplicated}')
+
+    overlapping_kwargs = sorted(set(sweep_names).intersection(fun_kwargs))
+    if overlapping_kwargs:
+        raise ValueError(f'Keyword arguments conflict with swept parameters: {overlapping_kwargs}. '
+                         f'Remove them from kwargs or param_names.')
+
+    if accepts_var_kwargs:
+        return
+
+    known_names = set(parameters)
+    unknown_sweep = sorted(name for name in sweep_names if name not in known_names)
+    if unknown_sweep:
+        raise ValueError(f'Unknown swept parameter names for function {fun.__name__}: {unknown_sweep}')
+
+    unknown_kwargs = sorted(name for name in fun_kwargs if name not in known_names)
+    if unknown_kwargs:
+        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]]]:
     # Check the depth of the parameters
 
-    if type(param_names) is str:
+    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 type(param_names[0]) is str:
+    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 type(param_values) is not list:
+        if not isinstance(param_values, list):
             raise ValueError('The parameters values must be a list of values')
-    elif type(param_names[0][0]) is str:
+    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):
+            raise ValueError('Parameter name groups must contain at least one parameter')
+        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 type(param_values[0]) is not list:
+        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')
@@ -227,14 +272,36 @@ def _format_input(param_names: Union[str, list], param_values: list) -> Tuple[Li
     if len(param_names) != len(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')
+        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:
         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]
+    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]
 
 
+def _reshape_channel_result(channel_values: List[Any], n_values: List[int]) -> np.ndarray:
+    array_result = np.array(channel_values)
+    if array_result.ndim == 0:
+        raise ValueError('Could not reshape scalar output')
+
+    target_shape = tuple(n_values) + tuple(array_result.shape[1:])
+    return array_result.reshape(target_shape)
+
+
 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,
@@ -298,6 +365,7 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
     time_start = time()
 
     param_names, param_values = _format_input(param_names, param_values)
+    _validate_function_arguments(fun, 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]
@@ -362,9 +430,9 @@ def parameterrun(fun: Callable[..., Any], param_names: Union[str, List[str], Lis
         if reshape:
             try:
                 if n_outputs == 1:
-                    result = np.array(result[0])
+                    result = _reshape_channel_result(result[0], n_values)
                 else:
-                    result = [np.array(result[i]) for i in range(n_outputs)]
+                    result = [_reshape_channel_result(result[i], n_values) for i in range(n_outputs)]
             except ValueError:
                 print('Could not reshape the result')
 

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

@@ -18,3 +18,19 @@ def test_format_input_multiple_parameters():
 def test_format_input_group_length_mismatch_raises():
     with pytest.raises(ValueError, match="same length"):
         _format_input([["x", "y"]], [[[1, 2], [10]]])
+
+
+def test_format_input_rejects_empty_parameter_name():
+    with pytest.raises(ValueError, match="non-empty"):
+        _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_rejects_duplicate_names():
+    with pytest.raises(ValueError, match="Duplicate parameter names"):
+        _format_input(["x", "x"], [[1, 2], [3, 4]])
+

{parameterrun-0.1.0 → parameterrun-0.2.1}/tests/test_parameter_run.py

@@ -9,7 +9,7 @@ def test_parameterrun_single_parameter_returns_1d_array():
         return x ** 2
 
     result = pu.parameterrun(square, param_names="x", param_values=[0, 1, 2, 3], n_workers=1, pbar_bool=False,
-                              backend="joblib", )
+                             backend="joblib", )
 
     assert isinstance(result, np.ndarray)
     np.testing.assert_array_equal(result, np.array([0, 1, 4, 9]))
@@ -20,11 +20,9 @@ def test_parameterrun_grouped_parameters_builds_expected_grid():
         return x + y + z + offset
 
     result = pu.parameterrun(f, param_names=[["x", "y"], ["z"]],
-                              param_values=[[[1, 2], [10, 20]],  # grouped pairs: (1,10), (2,20)
-                                            [[100, 200, 300]],  # second group scanned independently
-                                            ], n_workers=1, pbar_bool=False, backend="joblib", offset=5, )
-
-    result = result.reshape(2, 3)  # Reshape to match the expected output shape
+                             param_values=[[[1, 2], [10, 20]],  # grouped pairs: (1,10), (2,20)
+                                           [[100, 200, 300]],  # second group scanned independently
+                                           ], n_workers=1, pbar_bool=False, backend="joblib", offset=5, )
 
     expected = np.array([[116, 216, 316],  # (x,y) = (1,10)
                          [127, 227, 327],  # (x,y) = (2,20)
@@ -40,7 +38,7 @@ def test_parameterrun_multiple_outputs_returns_list_of_arrays():
         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", )
+                             backend="joblib", )
 
     assert isinstance(result, list)
     assert len(result) == 2
@@ -49,10 +47,25 @@ 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_keep_grid_shape():
+    def f(x, y):
+        return x + y, x * y
+
+    result = pu.parameterrun(f, param_names=["x", "y"], param_values=[[1, 2], [10, 20, 30]], n_workers=1,
+                             pbar_bool=False, backend="joblib", )
+
+    assert isinstance(result, list)
+    assert len(result) == 2
+    assert result[0].shape == (2, 3)
+    assert result[1].shape == (2, 3)
+
+    np.testing.assert_array_equal(result[0], np.array([[11, 21, 31], [12, 22, 32]]))
+    np.testing.assert_array_equal(result[1], np.array([[10, 20, 30], [20, 40, 60]]))
+
+
 def test_parameterrun_rejects_empty_parameter_groups():
     with pytest.raises(ValueError, match="at least one value"):
-        pu.parameterrun(lambda x: x, param_names="x", param_values=[], n_workers=1, pbar_bool=False,
-                         backend="joblib", )
+        pu.parameterrun(lambda x: x, param_names="x", param_values=[], n_workers=1, pbar_bool=False, backend="joblib", )
 
 
 def test_parameterrun_explicit_mpi_requires_mpi4py(monkeypatch):
@@ -74,3 +87,28 @@ def test_parameterrun_explicit_mpi_requires_mpi4py(monkeypatch):
 def test_parameterrun_invalid_backend():
     with pytest.raises(ValueError, match="Unknown backend"):
         pu.parameterrun(lambda x: x, "x", [1, 2], backend="bad", pbar_bool=False)
+
+
+def test_parameterrun_rejects_unknown_swept_parameters():
+    def f(x):
+        return x
+
+    with pytest.raises(ValueError, match="Unknown swept parameter"):
+        pu.parameterrun(f, param_names="y", param_values=[1, 2], n_workers=1, pbar_bool=False, backend="joblib", )
+
+
+def test_parameterrun_rejects_unknown_kwargs():
+    def f(x):
+        return x
+
+    with pytest.raises(ValueError, match="Unknown keyword arguments"):
+        pu.parameterrun(f, param_names="x", param_values=[1, 2], extra=3, n_workers=1, pbar_bool=False,
+                        backend="joblib", )
+
+
+def test_parameterrun_rejects_kwargs_conflicting_with_swept_parameters():
+    def f(x):
+        return x
+
+    with pytest.raises(ValueError, match="conflict with swept parameters"):
+        pu.parameterrun(f, param_names="x", param_values=[1, 2], x=99, n_workers=1, pbar_bool=False, backend="joblib", )

parameterrun-0.1.0/CHANGELOG.md

@@ -1,10 +0,0 @@
-# Changelog
-
-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.1.0] - 2026-03-25
-
-### Added
-- Initial public release of `parameterrun`

parameterrun-0.1.0/src/parameterrun/__init__.py

@@ -1,3 +0,0 @@
-from .parallel_utils import parameterrun
-
-__all__ = ["parameterrun"]