k-Wave-python 0.6.1__tar.gz → 0.6.3rc1__tar.gz

k_wave_python-0.6.3rc1/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"d51433dc-c558-4f37-a81d-dad121d6e869","pid":22144,"acquiredAt":1777832541181}

{k_wave_python-0.6.1/.claude/worktrees/add-agent-cli → k_wave_python-0.6.3rc1}/.claude/settings.local.json

@@ -39,7 +39,9 @@
       "Bash(KWAVE_DEVICE=cpu uv run python examples/us_bmode_phased_array/us_bmode_phased_array.py)",
       "Bash(KWAVE_DEVICE=cpu uv run python examples/checkpointing/checkpoint.py)",
       "Bash(KWAVE_FORCE_CPU=1 uv run python examples/pr_2D_FFT_line_sensor/pr_2D_FFT_line_sensor.py)",
-      "mcp__greptile__list_merge_request_comments"
+      "mcp__greptile__list_merge_request_comments",
+      "Bash(git:*)",
+      "Bash(wc -l /Users/Walter/git/k-wave-python/tests/*.py)"
     ]
   }
 }

k_wave_python-0.6.3rc1/CLAUDE.md

@@ -0,0 +1,95 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What is k-wave-python?
+
+Python implementation of the [k-Wave](http://www.k-wave.org/) acoustics toolbox for time-domain acoustic and ultrasound simulations. Two backends: a pure Python/NumPy/CuPy solver and C++ binaries (OMP/CUDA).
+
+## Commands
+
+```bash
+# Setup
+uv sync --extra dev --extra test
+uv run pre-commit install
+
+# Run tests
+uv run pytest                              # all tests
+uv run pytest tests/test_kgrid.py          # single file
+uv run pytest tests/test_kgrid.py::test_name  # single test
+uv run pytest -m integration               # MATLAB-reference tests only
+
+# Lint/format
+uv run ruff check . --fix
+uv run ruff format .
+uv run pre-commit run --all-files
+
+# Run an example
+uv run examples/ivp_homogeneous_medium.py
+
+# Build
+uv build
+```
+
+Always use `uv run` (not `uv run python`) for pytest, examples, and scripts.
+
+## Code Style
+
+- Line length: 140 (configured in `pyproject.toml` under `[tool.ruff]`)
+- Pre-commit hooks: ruff (lint + format), codespell, nb-clean
+- Ruff ignores F821 (nested function refs) and F722 (jaxtyping annotations)
+- Type annotations use `beartype` + `jaxtyping`
+
+## Architecture
+
+### Entry point
+
+`kwave/kspaceFirstOrder.py` — `kspaceFirstOrder()` is the unified API. It accepts `kgrid`, `medium`, `source`, `sensor` and dispatches to the appropriate backend.
+
+```
+kspaceFirstOrder(kgrid, medium, source, sensor, backend="python"|"cpp", device="cpu"|"gpu")
+```
+
+### Two backends
+
+- **Python backend** (`kwave/solvers/kspace_solver.py`): `Simulation` class implementing k-space pseudospectral method in NumPy/CuPy. Supports 1D/2D/3D. Uses CuPy for GPU when `device="gpu"`.
+- **C++ backend** (`kwave/solvers/cpp_simulation.py` + `kwave/executor.py`): Serializes to HDF5, invokes compiled C++ binary, reads results back. `save_only=True` writes HDF5 without running (for cluster jobs).
+
+### Core data classes
+
+- `kWaveGrid` (`kwave/kgrid.py`) — domain discretization, spacing, time array
+- `kWaveMedium` (`kwave/kmedium.py`) — sound speed, density, absorption, nonlinearity
+- `kSource` (`kwave/ksource.py`) — pressure/velocity sources with masks and signals
+- `kSensor` (`kwave/ksensor.py`) — sensor mask and recording configuration
+
+### Legacy path
+
+`kspaceFirstOrder2D()` / `kspaceFirstOrder3D()` in their respective files route through `kWaveSimulation` (`kwave/kWaveSimulation.py`) — a large legacy dataclass used by the C++ backend path. New code should use `kspaceFirstOrder()` directly.
+
+### PML handling
+
+When `pml_inside=False` (default), `kspaceFirstOrder()` expands the grid by `2*pml_size` before simulation and strips PML from full-grid output fields afterward. `pml_size="auto"` selects optimal sizes via `get_optimal_pml_size()`.
+
+### Key utilities
+
+- `kwave/utils/pml.py` — PML sizing (`get_pml()`, `get_optimal_pml_size()`)
+- `kwave/utils/mapgen.py` — geometry generators (`make_disc`, `make_ball`, `make_cart_circle`, etc.)
+- `kwave/utils/signals.py` — signal generation (tone bursts, filtering)
+- `kwave/utils/filters.py` — spatial smoothing, Gaussian filters
+- `kwave/utils/io.py` — HDF5 read/write
+- `kwave/utils/conversion.py` — unit conversion, `cart2grid`
+
+## Testing
+
+- Tests in `tests/`, configured via `[tool.pytest.ini_options]` in `pyproject.toml`
+- Integration tests (`@pytest.mark.integration`) compare against MATLAB reference data
+- Test fixtures in `tests/integration/conftest.py`: `load_matlab_ref` (fixture), `assert_fields_close` (helper function for field comparison)
+- MATLAB reference data for `@pytest.mark.integration` tests lives in `tests/matlab_test_data_collectors/python_testers/collectedValues/` (hardcoded in `conftest.py`)
+- `test_example_parity.py` (MATLAB-parity tests) reads `KWAVE_MATLAB_REF_DIR` (defaults to `~/git/k-wave-cupy/tests` if unset)
+
+## Naming Conventions
+
+- `backend="python"` or `"cpp"` (not "native")
+- `device="cpu"` or `"gpu"` (not `use_gpu` bool)
+- `quiet=True` to suppress output; `debug=True` for detailed output
+- `pml_size="auto"` for automatic PML sizing (not a separate boolean)

{k_wave_python-0.6.1 → k_wave_python-0.6.3rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k-Wave-python
-Version: 0.6.1
+Version: 0.6.3rc1
 Summary: Acoustics toolbox for time domain acoustic and ultrasound simulations in complex and tissue-realistic media.
 Project-URL: Homepage, http://www.k-wave.org/
 Project-URL: Documentation, https://waltersimson.com/k-wave-python/
@@ -179,31 +179,32 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Requires-Dist: beartype==0.22.9
-Requires-Dist: deepdiff==8.6.2
+Requires-Dist: deepdiff==9.1.0
 Requires-Dist: deprecated>=1.2.14
-Requires-Dist: h5py==3.15.1
-Requires-Dist: jaxtyping==0.3.2
-Requires-Dist: matplotlib==3.10.7
+Requires-Dist: h5py==3.16.0
+Requires-Dist: jaxtyping==0.3.7
+Requires-Dist: matplotlib==3.10.9
 Requires-Dist: numpy<2.3.0,>=1.22.2
 Requires-Dist: opencv-python==4.13.0.92
 Requires-Dist: scipy==1.15.3
 Requires-Dist: tqdm>=4.60
 Provides-Extra: dev
-Requires-Dist: pre-commit==4.5.1; extra == 'dev'
+Requires-Dist: pre-commit==4.6.0; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: furo==2024.8.6; extra == 'docs'
+Requires-Dist: furo==2025.12.19; extra == 'docs'
 Requires-Dist: sphinx-copybutton==0.5.2; extra == 'docs'
 Requires-Dist: sphinx-mdinclude==0.6.2; extra == 'docs'
-Requires-Dist: sphinx-tabs==3.4.7; extra == 'docs'
-Requires-Dist: sphinx-toolbox==3.8.0; extra == 'docs'
+Requires-Dist: sphinx-tabs==3.4.5; extra == 'docs'
+Requires-Dist: sphinx-toolbox==4.1.2; extra == 'docs'
+Requires-Dist: sphinx<9; extra == 'docs'
 Provides-Extra: example
-Requires-Dist: gdown==5.2.0; extra == 'example'
+Requires-Dist: gdown==6.1.0; extra == 'example'
 Provides-Extra: test
-Requires-Dist: coverage==7.10.6; extra == 'test'
+Requires-Dist: coverage==7.14.1; extra == 'test'
 Requires-Dist: phantominator; extra == 'test'
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-xdist; extra == 'test'
-Requires-Dist: requests==2.33.0; extra == 'test'
+Requires-Dist: requests==2.34.2; extra == 'test'
 Requires-Dist: testfixtures==8.3.0; extra == 'test'
 Description-Content-Type: text/markdown
 
@@ -213,7 +214,7 @@ Description-Content-Type: text/markdown
 [![Documentation Status](https://readthedocs.org/projects/k-wave-python/badge/?version=latest)](https://k-wave-python.readthedocs.io/en/latest/?badge=latest)
 [![codecov](https://codecov.io/gh/waltsims/k-wave-python/graph/badge.svg?token=6ofwtPiDNG)](https://codecov.io/gh/waltsims/k-wave-python)
 
-A Python implementation of [k-Wave](http://www.k-wave.org/) — an acoustics toolbox for time-domain simulation of acoustic wave fields. Includes a pure NumPy/CuPy solver (`backend="python"`) and an interface to the pre-compiled k-Wave C++ binaries (`backend="cpp"`) with NVIDIA GPU support (sm 5.0–9.0a).
+A Python implementation of [k-Wave](http://www.k-wave.org/) — an acoustics toolbox for time-domain simulation of acoustic wave fields. Includes a pure NumPy/CuPy solver (`backend="python"`, supports any CUDA-capable GPU) and an interface to the pre-compiled k-Wave C++ binaries (`backend="cpp"`) with NVIDIA GPU support for compute capability 7.5 (Turing) and newer — covers every consumer/datacenter GPU since 2018, including all shipping Blackwell variants (B200/GB200, B300/GB300, Jetson Thor, RTX 50xx, RTX PRO 6000 Blackwell, GB10/DGX Spark).
 
 ## Mission
 
@@ -245,6 +246,16 @@ Or with pip:
 pip install k-wave-python
 ```
 
+### Older GPUs (Maxwell, Pascal, Volta)
+
+The `backend="cpp"` binaries shipped in v0.6.3+ require compute capability 7.5 (Turing) or newer. CUDA Toolkit 13.0 removed offline-compilation support for older architectures, so the following hardware is not covered by the bundled binaries:
+
+- **Maxwell** (GTX 9xx, Titan X Maxwell, Tesla M-series, Jetson Nano)
+- **Pascal** (GTX 10xx, P100, P40, Titan X(p)/Xp, Jetson TX2)
+- **Volta** (V100, Titan V, Quadro GV100, Jetson AGX Xavier)
+
+Use `backend="python"` instead (NumPy/CuPy works on every CUDA-capable GPU), or build the C++ backend from source against CUDA Toolkit 12.x.
+
 ## Development
 
 Development instructions can be found [here](https://k-wave-python.readthedocs.io/en/latest/development/development_environment.html).

{k_wave_python-0.6.1 → k_wave_python-0.6.3rc1}/docs/README.md

@@ -4,7 +4,7 @@
 [![Documentation Status](https://readthedocs.org/projects/k-wave-python/badge/?version=latest)](https://k-wave-python.readthedocs.io/en/latest/?badge=latest)
 [![codecov](https://codecov.io/gh/waltsims/k-wave-python/graph/badge.svg?token=6ofwtPiDNG)](https://codecov.io/gh/waltsims/k-wave-python)
 
-A Python implementation of [k-Wave](http://www.k-wave.org/) — an acoustics toolbox for time-domain simulation of acoustic wave fields. Includes a pure NumPy/CuPy solver (`backend="python"`) and an interface to the pre-compiled k-Wave C++ binaries (`backend="cpp"`) with NVIDIA GPU support (sm 5.0–9.0a).
+A Python implementation of [k-Wave](http://www.k-wave.org/) — an acoustics toolbox for time-domain simulation of acoustic wave fields. Includes a pure NumPy/CuPy solver (`backend="python"`, supports any CUDA-capable GPU) and an interface to the pre-compiled k-Wave C++ binaries (`backend="cpp"`) with NVIDIA GPU support for compute capability 7.5 (Turing) and newer — covers every consumer/datacenter GPU since 2018, including all shipping Blackwell variants (B200/GB200, B300/GB300, Jetson Thor, RTX 50xx, RTX PRO 6000 Blackwell, GB10/DGX Spark).
 
 ## Mission
 
@@ -36,6 +36,16 @@ Or with pip:
 pip install k-wave-python
 ```
 
+### Older GPUs (Maxwell, Pascal, Volta)
+
+The `backend="cpp"` binaries shipped in v0.6.3+ require compute capability 7.5 (Turing) or newer. CUDA Toolkit 13.0 removed offline-compilation support for older architectures, so the following hardware is not covered by the bundled binaries:
+
+- **Maxwell** (GTX 9xx, Titan X Maxwell, Tesla M-series, Jetson Nano)
+- **Pascal** (GTX 10xx, P100, P40, Titan X(p)/Xp, Jetson TX2)
+- **Volta** (V100, Titan V, Quadro GV100, Jetson AGX Xavier)
+
+Use `backend="python"` instead (NumPy/CuPy works on every CUDA-capable GPU), or build the C++ backend from source against CUDA Toolkit 12.x.
+
 ## Development
 
 Development instructions can be found [here](https://k-wave-python.readthedocs.io/en/latest/development/development_environment.html).

k_wave_python-0.6.3rc1/kwave/__init__.py

@@ -0,0 +1,294 @@
+import hashlib
+import json
+import logging
+import os
+import platform
+import stat
+import warnings
+from pathlib import Path
+from typing import List
+from urllib.request import urlretrieve
+
+# Test installation with:
+# python3 -m pip install -i https://test.pypi.org/simple/ --extra-index-url=https://pypi.org/simple/ k-Wave-python==0.3.0
+__version__ = "0.6.3rc1"
+
+# Constants and Configurations
+URL_BASE = "https://github.com/waltsims/"
+BINARY_VERSION = "v1.4.2"
+# Single unified release hosts every platform binary + Windows runtime DLL
+# (consolidated from 5 mirror repos in v1.4.2; see kspacefirstorder-unified#13).
+# One version pin, one set of assets, one source-tree SHA. CUDA binary covers
+# compute capability 7.5+ (Turing through every Blackwell variant: B200/GB200,
+# B300/GB300, Jetson Thor, RTX 50xx, RTX PRO 6000 Blackwell, GB10/DGX Spark).
+_UNIFIED_RELEASE_URL = f"{URL_BASE}kspacefirstorder-unified/releases/download/{BINARY_VERSION}/"
+PLATFORM = platform.system().lower()
+
+if PLATFORM not in ["linux", "windows", "darwin"]:
+    raise NotImplementedError(f"k-wave-python is currently unsupported on this operating system: {PLATFORM}.")
+
+# darwin C++ binary is arm64-only; universal2 coverage tracked for v0.6.5
+DARWIN_BINARY_ARCH = "arm64"
+_darwin_unsupported = PLATFORM == "darwin" and platform.machine() != DARWIN_BINARY_ARCH
+if _darwin_unsupported:
+    warnings.warn(
+        f"k-wave-python's macOS C++ binary is {DARWIN_BINARY_ARCH}-only. "
+        f"Detected {platform.machine()} — the C++ backend (backend='cpp') will not run on this machine. "
+        "Use backend='python' instead. Universal2 (Intel + Apple Silicon) coverage is tracked for v0.6.5.",
+        RuntimeWarning,
+        stacklevel=2,
+    )
+
+# TODO: install directly in to /bin/ directory system directory is no longer needed
+# TODO: deprecate in 0.5.0
+BINARY_PATH = Path(__file__).parent / "bin" / PLATFORM
+BINARY_DIR = BINARY_PATH  # add alias for BINARY_PATH for now
+
+
+# Windows runtime DLLs shipped alongside both .exe files in the unified v1.4.2
+# release. The full bundle is downloaded for either backend selection because we
+# don't know at install time which the user will invoke. Verified against the
+# v1.4.2 release asset manifest (21 DLLs).
+WINDOWS_DLLS = [
+    # CUDA runtime (CUDA 13.0 — used by the CUDA backend)
+    "cudart64_13.dll",
+    "cufft64_12.dll",
+    # FFTW3 (used by the OMP backend)
+    "fftw3.dll",
+    "fftw3f.dll",
+    "fftw3l.dll",
+    # HDF5 + szip + zlib (from vcpkg; used by both backends)
+    "aec.dll",
+    "hdf5.dll",
+    "hdf5_hl.dll",
+    "szip.dll",
+    "zlib1.dll",
+    # OpenMP runtime (used by the OMP backend)
+    "vcomp140.dll",
+    # MSVC CRT (Concurrency Runtime + C++ stdlib + C runtime)
+    "concrt140.dll",
+    "msvcp140.dll",
+    "msvcp140_1.dll",
+    "msvcp140_2.dll",
+    "msvcp140_atomic_wait.dll",
+    "msvcp140_codecvt_ids.dll",
+    "vccorlib140.dll",
+    "vcruntime140.dll",
+    "vcruntime140_1.dll",
+    "vcruntime140_threads.dll",
+]
+
+EXECUTABLE_PREFIX = "kspaceFirstOrder-"
+ARCHITECTURES = ["omp", "cuda"]
+
+
+def _platform_binary_url(platform_name: str, architecture: str) -> list:
+    """URLs for a backend on a given platform from the unified v1.4.2+ release.
+
+    Takes ``platform_name`` explicitly so ``URL_DICT`` is correct for every OS
+    key, not just the host's. ``_darwin_unsupported`` only suppresses URLs
+    when actually running on darwin — building ``URL_DICT["darwin"]`` from a
+    Linux host still yields the canonical darwin asset URL.
+    """
+    if architecture == "cuda" and platform_name == "darwin":
+        return []
+    if platform_name == "darwin" and platform_name == PLATFORM and _darwin_unsupported:
+        return []
+    backend = "CUDA" if architecture == "cuda" else "OMP"
+    ext = ".exe" if platform_name == "windows" else ""
+    exe_url = f"{_UNIFIED_RELEASE_URL}{EXECUTABLE_PREFIX}{backend}-{platform_name}{ext}"
+    # Shared runtime DLLs ship with the OMP entry only — both backends find
+    # them at the same BINARY_PATH, so attaching to both would download the
+    # full 21-DLL bundle twice on first install.
+    dll_urls = [_UNIFIED_RELEASE_URL + dll for dll in WINDOWS_DLLS] if platform_name == "windows" and architecture == "omp" else []
+    return [exe_url] + dll_urls
+
+
+URL_DICT = {plat: {arch: _platform_binary_url(plat, arch) for arch in ARCHITECTURES} for plat in ["linux", "darwin", "windows"]}
+
+
+def _local_filename(asset_name: str) -> str:
+    """Map a unified-release asset name to the local install filename.
+
+    The unified release tags platform binaries with the platform name
+    (e.g. ``kspaceFirstOrder-CUDA-linux``, ``kspaceFirstOrder-OMP-windows.exe``)
+    to disambiguate them in the GitHub asset list. Consumer code expects the
+    bare backend name (``kspaceFirstOrder-CUDA``, ``kspaceFirstOrder-OMP``,
+    plus ``.exe`` on Windows). Non-prefixed assets (DLLs, etc.) pass through.
+    """
+    if not asset_name.startswith(EXECUTABLE_PREFIX):
+        return asset_name
+    backend = asset_name.split("-", 2)[1]
+    ext = ".exe" if asset_name.endswith(".exe") else ""
+    return f"{EXECUTABLE_PREFIX}{backend}{ext}"
+
+
+def _hash_file(filepath: str) -> str:
+    buf_size = 65536  # 64kb chunks
+    md5 = hashlib.md5()
+
+    with open(filepath, "rb") as f:
+        while True:
+            data = f.read(buf_size)
+            if not data:
+                break
+            md5.update(data)
+    return md5.hexdigest()
+
+
+def _ensure_executable(binary_filepath) -> None:
+    # Self-heal the executable bit on Linux/macOS. urlretrieve creates files
+    # at 0644, and prior versions of this package didn't fix that up, so users
+    # upgrading with a cached non-executable binary on disk would otherwise
+    # stay stuck (the cache check below returns True and skips re-download).
+    # Any OS-level failure here (broken symlink, read-only FS, wrong ownership,
+    # TOCTOU race) is degraded to a warning so it never aborts `import kwave`.
+    if PLATFORM == "windows":
+        return
+    try:
+        current_mode = os.stat(binary_filepath).st_mode
+        desired_mode = current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+        if current_mode == desired_mode:
+            return
+        os.chmod(binary_filepath, desired_mode)
+    except OSError:  # pragma: no cover - defensive; degrades to warning, never fatal
+        # Don't abort import. The user can chmod +x manually or reinstall
+        # into a writable location.
+        logging.warning(
+            "kwave: cannot set executable bit on %s — backend='cpp' may fail with "
+            "Permission denied. Run `chmod +x` manually or reinstall.",
+            binary_filepath,
+        )
+
+
+def _is_binary_present(binary_name: str, binary_type: str) -> bool:
+    binary_filepath = BINARY_PATH / binary_name
+    binary_file_exists = os.path.exists(binary_filepath)
+    if not binary_file_exists:
+        return False
+
+    if binary_type is None:
+        # this is non-kwave windows binary
+        # it already exists according to the check above
+        return True
+    existing_metadata_path = BINARY_PATH / f"{binary_name}_metadata.json"
+
+    if not os.path.exists(existing_metadata_path):
+        # metadata does not exist => binaries may or may not exist
+        # Let's play safe and claim they don't exist
+        # This will trigger binary download and generation of binary metadata
+        return False
+    existing_metadata = json.loads(Path(existing_metadata_path).read_text())
+
+    # If metadata was somehow corrupted
+    file_hash = _hash_file(binary_filepath)
+    if existing_metadata["file_hash"] != file_hash:
+        return False
+
+    # If there is a new binary
+    latest_urls = URL_DICT[PLATFORM][binary_type]
+    if existing_metadata["url"] not in latest_urls:
+        return False
+
+    _ensure_executable(binary_filepath)
+
+    # No need to check `version` field for now
+    # because we version is already present in the URL
+    return True
+
+
+def binaries_present() -> bool:
+    """
+    Check if binaries are present
+    Returns:
+        bool, True if binaries are present, False otherwise
+
+    """
+    binary_list = []
+    for binary_type in ARCHITECTURES:
+        for url in URL_DICT[PLATFORM][binary_type]:
+            binary_list.append((_local_filename(url.split("/")[-1]), binary_type))
+
+    missing_binaries: List[str] = []
+
+    for binary_name, binary_type in binary_list:
+        if not _is_binary_present(binary_name, binary_type):
+            missing_binaries.append(binary_name)
+
+    if len(missing_binaries) > 0:
+        missing_binaries_str = ", ".join(missing_binaries)
+        logging.log(
+            logging.INFO,
+            f"Following binaries were not found: {missing_binaries_str}"
+            "If this is first time you're running k-wave-python, "
+            "binaries will be downloaded automatically.",
+        )
+
+    return len(missing_binaries) == 0
+
+
+def _record_binary_metadata(binary_version: str, binary_filepath: str, binary_url: str, filename: str) -> None:
+    # note: version is not immediately useful at the moment
+    # because it is already present in the url and we use url to understand if versions match
+    # However, let's record it anyway. Maybe it will be useful in the future.
+    metadata = {"url": binary_url, "version": binary_version, "file_hash": _hash_file(binary_filepath)}
+    metadata_filename = f"{filename}_metadata.json"
+    metadata_filepath = BINARY_PATH / metadata_filename
+    with open(metadata_filepath, "w") as outfile:
+        json.dump(metadata, outfile, indent=4)
+
+
+def download_binaries(system_os: str, bin_type: str):
+    """
+    Download binary from release url
+    Args:
+        system_os: string, current system type
+        bin_type: string of "OMP" or "CUDA"
+
+    Returns:
+        None
+
+    """
+    for url in URL_DICT[system_os][bin_type]:
+        # Extract the asset name from the GitHub release URL, then map it to
+        # the local install filename consumer code expects (see _local_filename).
+        binary_version, asset_name = url.split("/")[-2:]
+        filename = _local_filename(asset_name)
+
+        logging.log(logging.INFO, f"Downloading {asset_name} -> {filename} in {BINARY_PATH}...")
+
+        # Create the directory if it does not yet exist
+        os.makedirs(BINARY_PATH, exist_ok=True)
+
+        # Download the binary file
+        try:
+            binary_filepath = os.path.join(BINARY_PATH, filename)
+            urlretrieve(url, binary_filepath)
+            _ensure_executable(binary_filepath)
+            _record_binary_metadata(binary_version=binary_version, binary_filepath=binary_filepath, binary_url=url, filename=filename)
+
+        except TimeoutError:
+            logging.log(
+                logging.WARN,
+                f"Download of {filename} timed out. "
+                "This can be due to slow internet connection. "
+                "Partially downloaded files will be removed.",
+            )
+            try:
+                os.remove(BINARY_PATH)
+            except Exception:
+                folder_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "bin")
+                logging.warning(
+                    "Error occurred while removing partially downloaded binary. "
+                    f"Please manually delete the `{folder_path}` folder which "
+                    "can be found in your virtual environment."
+                )
+
+
+def install_binaries():
+    for binary_type in ARCHITECTURES:
+        download_binaries(PLATFORM, binary_type)
+
+
+if not binaries_present():
+    install_binaries()

{k_wave_python-0.6.1 → k_wave_python-0.6.3rc1}/kwave/compat.py

@@ -39,7 +39,13 @@ def options_to_kwargs(simulation_options=None, execution_options=None):
         kwargs["use_kspace"] = opts.use_kspace
         kwargs["smooth_p0"] = opts.smooth_p0
         if opts.data_path is not None:
-            kwargs["data_path"] = opts.data_path
+            import os
+            from tempfile import gettempdir
+
+            normalized_data_path = os.path.realpath(os.path.normpath(os.fspath(opts.data_path)))
+            normalized_tempdir = os.path.realpath(os.path.normpath(os.fspath(gettempdir())))
+            if normalized_data_path != normalized_tempdir:
+                kwargs["data_path"] = opts.data_path
         if opts.save_to_disk_exit:
             kwargs["save_only"] = True
 
@@ -70,5 +76,9 @@ def options_to_kwargs(simulation_options=None, execution_options=None):
             kwargs["num_threads"] = opts.num_threads
         if opts.device_num is not None:
             kwargs["device_num"] = opts.device_num
+        # Read _binary_path directly: the property auto-resolves to a default,
+        # so it can't distinguish a user-set path from one.
+        if opts._binary_path is not None:
+            kwargs["binary_path"] = opts._binary_path
 
     return kwargs

{k_wave_python-0.6.1 → k_wave_python-0.6.3rc1}/kwave/enums.py

@@ -1,5 +1,17 @@
 from enum import Enum
 
+
+class AlphaMode(str, Enum):
+    """Controls which absorption/dispersion terms are included in the equation of state."""
+
+    NO_ABSORPTION = "no_absorption"
+    NO_DISPERSION = "no_dispersion"
+    STOKES = "stokes"
+
+    def __str__(self):
+        return self.value
+
+
 ################################################################
 # literals that link the discrete cosine and sine transform types with
 # their type definitions in the functions dtt1D, dtt2D, and dtt3D

{k_wave_python-0.6.1 → k_wave_python-0.6.3rc1}/kwave/kWaveSimulation_helper/create_absorption_variables.py

@@ -12,19 +12,19 @@ def create_absorption_variables(kgrid: kWaveGrid, medium: kWaveMedium, equation_
     # define the lossy derivative operators and proportionality coefficients
     """
     Selects and returns absorption and dispersion operators and coefficients for the given medium based on the equation of state.
-    
+
     Parameters:
         kgrid (kWaveGrid): Grid object providing wavenumber array via `kgrid.k`.
         medium (kWaveMedium): Medium properties used to compute absorption/dispersion coefficients.
         equation_of_state (str): One of `"absorbing"`, `"stokes"`, or `"lossless"` determining which variables to produce.
-    
+
     Returns:
         tuple: (nabla1, nabla2, tau, eta)
             - nabla1: First-order absorption operator or `None` when not applicable.
             - nabla2: Dispersion operator or `None` when not applicable.
             - tau: Absorbing coefficient or `None` when not applicable.
             - eta: Dispersive coefficient or `None` when not applicable.
-    
+
     Behavior:
         - "absorbing": returns (nabla1, nabla2, tau, eta) computed for an absorbing medium.
         - "stokes": returns (None, None, tau, None) where `tau` is the Stokes absorbing coefficient.
@@ -127,4 +127,4 @@ def apply_alpha_filter(medium, nabla1, nabla2):
     # shift the parameters back
     nabla1 = np.fft.ifftshift(nabla1)
     nabla2 = np.fft.ifftshift(nabla2)
-    return nabla1, nabla2
+    return nabla1, nabla2

{k_wave_python-0.6.1 → k_wave_python-0.6.3rc1}/kwave/kgrid.py

@@ -108,7 +108,7 @@ class kWaveGrid(object):
     @t_array.setter
     def t_array(self, t_array):
         # check for 'auto' input
-        if t_array == "auto":
+        if isinstance(t_array, str) and t_array == "auto":
             # set values to auto
             self.Nt = "auto"
             self.dt = "auto"