dask-setup 2.1.0__tar.gz → 2.2.0__tar.gz

{dask_setup-2.1.0/src/dask_setup.egg-info → dask_setup-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dask_setup
-Version: 2.1.0
+Version: 2.2.0
 Summary: HPC-tuned Dask helpers for single-node runs on NCI Gadi.
 Author: Sam Green
 Project-URL: Homepage, https://github.com/21centuryweather/dask_setup
@@ -11,12 +11,15 @@ Requires-Dist: dask>=2024.1.0
 Requires-Dist: distributed>=2024.1.0
 Requires-Dist: psutil>=5.9
 Requires-Dist: pyyaml>=6.0
+Provides-Extra: multinode
+Requires-Dist: dask-jobqueue>=0.8; extra == "multinode"
 Provides-Extra: dev
-Requires-Dist: ruff~=0.4; extra == "dev"
+Requires-Dist: ruff==0.16.4; extra == "dev"
 Requires-Dist: pytest~=8.2; extra == "dev"
 Requires-Dist: pytest-cov~=5.0; extra == "dev"
 Requires-Dist: xarray; extra == "dev"
 Requires-Dist: numpy; extra == "dev"
+Requires-Dist: dask-jobqueue>=0.8; extra == "dev"
 Dynamic: license-file
 
 # dask_setup
@@ -35,9 +38,9 @@ HPC-tuned Dask helpers for **NCI Gadi** and other PBS/SLURM systems. Wraps `dask
 from dask_setup import setup_dask_client
 
 # Pick a workload type and go
-client, cluster, dask_tmp = setup_dask_client("cpu")   # heavy compute
-client, cluster, dask_tmp = setup_dask_client("io")    # heavy file I/O
-client, cluster, dask_tmp = setup_dask_client("mixed") # both
+client, cluster, dask_tmp = setup_dask_client(mode="interactive", workload_type="cpu")   # heavy compute
+client, cluster, dask_tmp = setup_dask_client(mode="interactive", workload_type="io")    # heavy file I/O
+client, cluster, dask_tmp = setup_dask_client(mode="interactive", workload_type="mixed") # both
 ```
 
 `dask_tmp` is the path to the spill/temp directory (on `$PBS_JOBFS` if available). Pass it to Rechunker, Zarr, or anywhere else you want fast local I/O.
@@ -95,14 +98,27 @@ client, cluster, shared_tmp = setup_dask_client(
 |-----------|---------|-------------|
 | `workload_type` | `"io"` | Worker topology: `"cpu"`, `"io"`, `"mixed"`, `"gpu"`, `"auto"` |
 | `max_workers` | all cores | Hard cap on worker count |
-| `reserve_mem_gb` | auto (20% RAM) | Memory held back for OS/cache (GiB) |
+| `reserve_mem_gb` | auto | Memory held back for OS/cache (GiB): 20% of RAM, clamped to [4, 50] |
 | `max_mem_gb` | total RAM | Upper bound on Dask's total memory use |
 | `dashboard` | `True` | Start dashboard and print SSH tunnel hint |
 | `profile` | `None` | Named config profile |
-| `config` | `None` | Pre-built `DaskSetupConfig` object — mutually exclusive with `profile` |
+| `config` | `None` | Pre-built `DaskSetupConfig` object — same layer as `profile`; if both are given, `profile` wins |
 | `mode` | `"auto"` | `"local"`, `"pbs"`, `"slurm"`, or `"auto"` (v2.0) |
 | `multi_node_config` | `None` | `MultiNodeConfig` for PBS/SLURM multi-node jobs (v2.0) |
 
+Settings are layered, lowest to highest:
+
+```
+library defaults  <  config= or profile=  <  explicit keyword arguments
+```
+
+A parameter you leave unset inherits from the layer below. Passing a value
+always overrides, even when that value happens to equal the default — so
+`reserve_mem_gb=50.0` overrides a profile that says 40.0.
+
+`config=` and `profile=` share a layer rather than stacking: pass one or the
+other, and use explicit keyword arguments for the differences.
+
 ---
 
 ## Common Patterns
@@ -177,6 +193,14 @@ Tunnel from your laptop:
 Then open: http://localhost:8787
 ```
 
+The login host is inferred from the compute node's DNS domain, so it is correct
+at other sites too. Override it with `$DASK_SETUP_LOGIN_HOST` if the guess is
+wrong:
+
+```bash
+export DASK_SETUP_LOGIN_HOST=login.mycluster.edu
+```
+
 ---
 
 ## CLI

dask_setup-2.1.0/PKG-INFO → dask_setup-2.2.0/README.md

@@ -1,24 +1,3 @@
-Metadata-Version: 2.4
-Name: dask_setup
-Version: 2.1.0
-Summary: HPC-tuned Dask helpers for single-node runs on NCI Gadi.
-Author: Sam Green
-Project-URL: Homepage, https://github.com/21centuryweather/dask_setup
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: dask>=2024.1.0
-Requires-Dist: distributed>=2024.1.0
-Requires-Dist: psutil>=5.9
-Requires-Dist: pyyaml>=6.0
-Provides-Extra: dev
-Requires-Dist: ruff~=0.4; extra == "dev"
-Requires-Dist: pytest~=8.2; extra == "dev"
-Requires-Dist: pytest-cov~=5.0; extra == "dev"
-Requires-Dist: xarray; extra == "dev"
-Requires-Dist: numpy; extra == "dev"
-Dynamic: license-file
-
 # dask_setup
 
 [![CI](https://github.com/21centuryweather/dask_setup/workflows/CI/badge.svg)](https://github.com/21centuryweather/dask_setup/actions)
@@ -35,9 +14,9 @@ HPC-tuned Dask helpers for **NCI Gadi** and other PBS/SLURM systems. Wraps `dask
 from dask_setup import setup_dask_client
 
 # Pick a workload type and go
-client, cluster, dask_tmp = setup_dask_client("cpu")   # heavy compute
-client, cluster, dask_tmp = setup_dask_client("io")    # heavy file I/O
-client, cluster, dask_tmp = setup_dask_client("mixed") # both
+client, cluster, dask_tmp = setup_dask_client(mode="interactive", workload_type="cpu")   # heavy compute
+client, cluster, dask_tmp = setup_dask_client(mode="interactive", workload_type="io")    # heavy file I/O
+client, cluster, dask_tmp = setup_dask_client(mode="interactive", workload_type="mixed") # both
 ```
 
 `dask_tmp` is the path to the spill/temp directory (on `$PBS_JOBFS` if available). Pass it to Rechunker, Zarr, or anywhere else you want fast local I/O.
@@ -95,14 +74,27 @@ client, cluster, shared_tmp = setup_dask_client(
 |-----------|---------|-------------|
 | `workload_type` | `"io"` | Worker topology: `"cpu"`, `"io"`, `"mixed"`, `"gpu"`, `"auto"` |
 | `max_workers` | all cores | Hard cap on worker count |
-| `reserve_mem_gb` | auto (20% RAM) | Memory held back for OS/cache (GiB) |
+| `reserve_mem_gb` | auto | Memory held back for OS/cache (GiB): 20% of RAM, clamped to [4, 50] |
 | `max_mem_gb` | total RAM | Upper bound on Dask's total memory use |
 | `dashboard` | `True` | Start dashboard and print SSH tunnel hint |
 | `profile` | `None` | Named config profile |
-| `config` | `None` | Pre-built `DaskSetupConfig` object — mutually exclusive with `profile` |
+| `config` | `None` | Pre-built `DaskSetupConfig` object — same layer as `profile`; if both are given, `profile` wins |
 | `mode` | `"auto"` | `"local"`, `"pbs"`, `"slurm"`, or `"auto"` (v2.0) |
 | `multi_node_config` | `None` | `MultiNodeConfig` for PBS/SLURM multi-node jobs (v2.0) |
 
+Settings are layered, lowest to highest:
+
+```
+library defaults  <  config= or profile=  <  explicit keyword arguments
+```
+
+A parameter you leave unset inherits from the layer below. Passing a value
+always overrides, even when that value happens to equal the default — so
+`reserve_mem_gb=50.0` overrides a profile that says 40.0.
+
+`config=` and `profile=` share a layer rather than stacking: pass one or the
+other, and use explicit keyword arguments for the differences.
+
 ---
 
 ## Common Patterns
@@ -177,6 +169,14 @@ Tunnel from your laptop:
 Then open: http://localhost:8787
 ```
 
+The login host is inferred from the compute node's DNS domain, so it is correct
+at other sites too. Override it with `$DASK_SETUP_LOGIN_HOST` if the guess is
+wrong:
+
+```bash
+export DASK_SETUP_LOGIN_HOST=login.mycluster.edu
+```
+
 ---
 
 ## CLI

{dask_setup-2.1.0 → dask_setup-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dask_setup"
-version = "2.1.0"
+version = "2.2.0"
 description = "HPC-tuned Dask helpers for single-node runs on NCI Gadi."
 authors = [{name="Sam Green"}]
 readme = "README.md"
@@ -23,13 +23,28 @@ Homepage = "https://github.com/21centuryweather/dask_setup"
 dask-setup = "dask_setup.cli:main"
 
 [project.optional-dependencies]
+# Multi-node PBS/SLURM cluster support. Optional: the single-node path never
+# imports it, and setup_pbs_cluster()/setup_slurm_cluster() raise a helpful
+# ImportError if it is missing.
+multinode = [
+    "dask-jobqueue>=0.8",
+]
+
 dev = [
-    "ruff ~= 0.4",
+    # Pinned exactly, not a range. `ruff ~= 0.4` means >=0.4,<1.0, so CI picked
+    # up whatever ruff had released that morning -- and ruff's formatter changes
+    # between minor versions. That turns `ruff format --check` into a job that
+    # can fail on a commit that touched nothing. Bump this deliberately.
+    "ruff == 0.16.4",
     "pytest ~= 8.2",
     "pytest-cov ~= 5.0",
     # Xarray integration testing
     "xarray",
     "numpy",
+    # Multi-node tests exercise a real PBSJob. Without this, CI silently skipped
+    # the multi-node path -- including the regression test for the 4x worker
+    # under-provisioning fixed in 2.2.0.
+    "dask-jobqueue>=0.8",
 ]
 
 [tool.setuptools.package-data]

{dask_setup-2.1.0 → dask_setup-2.2.0}/src/dask_setup/__init__.py

@@ -281,7 +281,7 @@ except ImportError:
         )
 
 
-__version__ = "2.1.0"
+__version__ = "2.2.0"
 
 __all__ = [
     # Core API — always available

{dask_setup-2.1.0 → dask_setup-2.2.0}/src/dask_setup/benchmark.py

@@ -46,11 +46,15 @@ from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
+from .logging import get_logger
+
 if TYPE_CHECKING:
     from dask.distributed import Client
 
     from .config import DaskSetupConfig
 
+logger = get_logger("benchmark")
+
 __all__ = [
     "BenchmarkResult",
     "ScalingResult",
@@ -125,7 +129,10 @@ class BenchmarkResult:
     wall_time_std : float
         Standard deviation of per-repeat wall times (0.0 for a single repeat).
     peak_memory_gib : float
-        Maximum in-memory data across all workers at the end of the run.
+        Highest total worker process memory (RSS summed across workers)
+        observed *during* the timed runs, sampled every 0.2 s.  If in-flight
+        sampling was unavailable this falls back to a post-run reading and an
+        explanatory note is appended to ``errors``.
     spill_gib : float
         Total data written to disk spill storage during the run.
     n_tasks : int
@@ -461,6 +468,55 @@ class ChunkImpactResult:
 # ---------------------------------------------------------------------------
 
 
+@contextlib.contextmanager
+def _sample_peak_memory(client: Client) -> Any:
+    """Record peak cluster memory *while* the enclosed block runs.
+
+    Reading ``cluster_report(client).peak_memory_gib`` after ``.compute()``
+    returns does not measure a peak: by then the graph is done and the workers
+    have already released the data, so the figure is close to zero for exactly
+    the workloads whose memory use matters.
+
+    Yields a dict that is filled in on exit::
+
+        {"peak_gib": float, "sampled": bool}
+
+    ``sampled`` is ``False`` when no in-flight sampling was possible (older
+    ``distributed``, or a scheduler that refused the periodic callback), which
+    tells the caller to fall back to the post-run reading rather than report a
+    peak of 0.0.
+    """
+    result: dict[str, Any] = {"peak_gib": 0.0, "sampled": False}
+
+    label = "dask_setup_benchmark"
+    sampler = None
+    ctx = None
+    try:
+        from distributed.diagnostics import MemorySampler
+
+        sampler = MemorySampler()
+        # measure="process" is total RSS across workers -- the number that
+        # decides whether a job fits in its memory allocation.
+        ctx = sampler.sample(label, client=client, measure="process", interval=0.2)
+        ctx.__enter__()
+    except Exception as e:  # pragma: no cover - depends on distributed version
+        logger.debug("In-flight memory sampling unavailable", error=str(e))
+        ctx = None
+
+    try:
+        yield result
+    finally:
+        if ctx is not None:
+            try:
+                ctx.__exit__(None, None, None)
+                samples = (sampler.samples or {}).get(label) or []
+                peak_bytes = max((float(b) for _t, b in samples), default=0.0)
+                result["peak_gib"] = peak_bytes / (1024**3)
+                result["sampled"] = bool(samples)
+            except Exception as e:
+                logger.debug("Could not read memory samples", error=str(e))
+
+
 def _measure_one(
     ds: Any,
     operation_fn: Callable[[Any], Any],
@@ -507,23 +563,24 @@ def _measure_one(
     with contextlib.suppress(Exception):
         n_workers = len(client.scheduler_info().get("workers", {}))
 
-    # Optional warmup
+    # Optional warmup (not sampled -- it is not part of the measured run)
     if warmup:
         try:
             operation_fn(ds).compute()
         except Exception as e:
             errors.append(f"Warmup failed: {e}")
 
-    # Timed runs
-    for i in range(repeats):
-        t0 = time.monotonic()
-        try:
-            operation_fn(ds).compute()
-        except Exception as e:
-            errors.append(f"Run {i + 1}/{repeats} failed: {e}")
-            times.append(float("inf"))
-        else:
-            times.append(time.monotonic() - t0)
+    # Timed runs, with memory sampled while they are in flight
+    with _sample_peak_memory(client) as mem_samples:
+        for i in range(repeats):
+            t0 = time.monotonic()
+            try:
+                operation_fn(ds).compute()
+            except Exception as e:
+                errors.append(f"Run {i + 1}/{repeats} failed: {e}")
+                times.append(float("inf"))
+            else:
+                times.append(time.monotonic() - t0)
 
     # Filter infinities (failed runs)
     valid_times = [t for t in times if t != float("inf")]
@@ -535,8 +592,13 @@ def _measure_one(
         from .reporting import cluster_report
 
         report = cluster_report(client)
-        peak_mem = report.peak_memory_gib
         spill = report.total_spill_gib
+        # Prefer the in-flight peak; the post-run reading is a floor at best.
+        if mem_samples["sampled"]:
+            peak_mem = mem_samples["peak_gib"]
+        else:
+            peak_mem = report.peak_memory_gib
+            errors.append("Peak memory sampled after the run; treat it as a lower bound")
     except Exception as e:
         errors.append(f"Metrics collection failed: {e}")
 
@@ -701,15 +763,16 @@ def scaling_analysis(
     repeats: int = 1,
     warmup: bool = False,
     fallback_on_detection_failure: bool = True,
+    mode: str = "local",
     plot: bool = False,
     verbose: bool = False,
 ) -> ScalingResult:
     """Measure parallel scaling across different worker counts.
 
-    For each entry in *worker_counts*, a fresh cluster is created with
-    ``max_workers`` set to that count and the operation is timed.  The
-    resulting :class:`ScalingResult` includes speedup and efficiency
-    relative to the single-worker baseline.
+    For each entry in *worker_counts*, a fresh **local** cluster is created
+    with ``max_workers`` set to that count and the operation is timed.  The
+    resulting :class:`ScalingResult` includes speedup and efficiency relative
+    to the single-worker baseline.
 
     Parameters
     ----------
@@ -730,6 +793,13 @@ def scaling_analysis(
         Run one un-timed warmup pass before timing.
     fallback_on_detection_failure:
         Passed to :func:`~dask_setup.client.setup_dask_client`.
+    mode:
+        Cluster mode passed to :func:`~dask_setup.client.setup_dask_client`.
+        Defaults to ``"local"`` so that the sweep always uses a
+        ``LocalCluster`` on the current node — this prevents auto-detection
+        from dispatching to PBS/SLURM and submitting child scheduler jobs,
+        which would time out and produce NaN results.  Pass ``"auto"`` only
+        if you specifically want multi-node dispatch for each sweep step.
     plot:
         If ``True``, call :meth:`ScalingResult.plot` and display the figure
         (requires matplotlib).
@@ -748,11 +818,33 @@ def scaling_analysis(
     counts = list(worker_counts)
 
     if base_config is None:
-        base_config = DaskSetupConfig(fallback_on_detection_failure=True)
+        # workload_type="cpu" is the only default under which this sweep means
+        # anything: decide_topology() pins n_workers=1 for "io" (and for "gpu"
+        # with no GPU present) regardless of max_workers, so an "io" sweep
+        # builds the same single-worker cluster at every point and the
+        # "scaling curve" is just timing noise.
+        base_config = DaskSetupConfig(workload_type="cpu", fallback_on_detection_failure=True)
+
+    # Use tqdm for progress if available (works in both terminals and Jupyter).
+    # tqdm.auto automatically picks the right bar type (notebook vs terminal).
+    try:
+        from tqdm.auto import tqdm as _tqdm
+
+        count_iter = _tqdm(counts, desc="scaling sweep", unit="config")
+    except ImportError:
+        count_iter = counts  # type: ignore[assignment]
 
     raw_results: list[BenchmarkResult] = []
 
-    for nw in counts:
+    for nw in count_iter:
+        # Show live status so notebook users know what's running right now.
+        # tqdm will show this as a postfix label; without tqdm it's a plain print.
+        _status = f"workers={nw} ({len(raw_results) + 1}/{len(counts)})"
+        try:
+            count_iter.set_postfix_str(_status)  # type: ignore[union-attr]
+        except AttributeError:
+            print(f"[scaling_analysis] running {_status}…", flush=True)
+
         # Clone config with this worker count
         cfg_dict = base_config.to_dict()
         cfg_dict["max_workers"] = nw
@@ -766,8 +858,12 @@ def scaling_analysis(
 
         try:
             client, cluster, _tmp = setup_dask_client(
+                # cfg already carries max_workers=nw and adaptive=False; every
+                # field of a config= object is now honoured, so there is no
+                # need to re-pass them as explicit keyword arguments.
                 config=cfg,
                 fallback_on_detection_failure=fallback_on_detection_failure,
+                mode=mode,
                 dashboard=False,
             )
             result = _measure_one(
@@ -803,15 +899,36 @@ def scaling_analysis(
     if not baseline_time or baseline_time != baseline_time:  # nan check
         baseline_time = 1.0
 
+    # Efficiency is speedup relative to the *ratio* of workers, not to the
+    # absolute worker count.  Dividing by nw made a sweep that starts anywhere
+    # other than 1 worker report a fraction of its true efficiency: a perfect
+    # (4, 8) sweep scored 0.25 at its own baseline.
+    actual_counts = [r.n_workers or nw for r, nw in zip(raw_results, counts, strict=False)]
+    baseline_workers = actual_counts[0] if actual_counts else 1
+
     speedups = []
     efficiencies = []
-    for r, nw in zip(raw_results, counts, strict=False):
+    for r, nw in zip(raw_results, actual_counts, strict=False):
         if r.wall_time_seconds and r.wall_time_seconds == r.wall_time_seconds:
             sp = baseline_time / r.wall_time_seconds
         else:
             sp = float("nan")
         speedups.append(sp)
-        efficiencies.append(sp / nw if nw > 0 else float("nan"))
+        worker_ratio = (nw / baseline_workers) if (nw > 0 and baseline_workers > 0) else 0.0
+        efficiencies.append(sp / worker_ratio if worker_ratio > 0 else float("nan"))
+
+    # A sweep in which the cluster never actually changed size produces a
+    # meaningless curve.  Say so rather than letting the caller read noise as
+    # a scaling result.
+    distinct = {n for n in actual_counts if n > 0}
+    if len(counts) > 1 and len(distinct) == 1:
+        logger.warning(
+            "Scaling sweep ran at a constant worker count; the curve is not a scaling result",
+            requested=counts,
+            actual=actual_counts[0] if actual_counts else 0,
+            workload_type=base_config.workload_type,
+            hint="workload_type='io'/'gpu' pin n_workers=1; use workload_type='cpu' or 'mixed'",
+        )
 
     scaling = ScalingResult(
         results=raw_results,
@@ -823,10 +940,18 @@ def scaling_analysis(
     if plot:
         fig = scaling.plot()
         if fig is not None:
-            with contextlib.suppress(Exception):
-                import matplotlib.pyplot as plt
+            # In Jupyter, use IPython's display() so the figure renders inline
+            # in the cell output rather than via plt.show() which can misbehave
+            # in some notebook backends.
+            try:
+                from IPython.display import display as _ipy_display
+
+                _ipy_display(fig)
+            except ImportError:
+                with contextlib.suppress(Exception):
+                    import matplotlib.pyplot as plt
 
-                plt.show()
+                    plt.show()
 
     return scaling
 
@@ -902,9 +1027,25 @@ def chunk_impact(
             _generate_auto_chunks(dims) if auto_chunks and dims else [{}]
         )  # single run with no rechunking
 
+    # Use tqdm for progress if available (works in both terminals and Jupyter).
+    # tqdm.auto automatically picks the right bar type (notebook vs terminal).
+    try:
+        from tqdm.auto import tqdm as _tqdm
+
+        chunk_iter = _tqdm(chunk_sizes, desc="chunk sweep", unit="config")
+    except ImportError:
+        chunk_iter = chunk_sizes  # type: ignore[assignment]
+
     raw_results: list[BenchmarkResult] = []
 
-    for cs in chunk_sizes:
+    for cs in chunk_iter:
+        # Show live status so notebook users know what's running right now.
+        _status = f"{cs} ({len(raw_results) + 1}/{len(chunk_sizes)})"
+        try:
+            chunk_iter.set_postfix_str(_status)  # type: ignore[union-attr]
+        except AttributeError:
+            print(f"[chunk_impact] running {_status}…", flush=True)
+
         errors: list[str] = []
         ds_chunked = ds
 
@@ -950,10 +1091,18 @@ def chunk_impact(
         first_dim = next(iter(dims), None)
         fig = impact.plot(dim=first_dim)
         if fig is not None:
-            with contextlib.suppress(Exception):
-                import matplotlib.pyplot as plt
+            # In Jupyter, use IPython's display() so the figure renders inline
+            # in the cell output rather than via plt.show() which can misbehave
+            # in some notebook backends.
+            try:
+                from IPython.display import display as _ipy_display
 
-                plt.show()
+                _ipy_display(fig)
+            except ImportError:
+                with contextlib.suppress(Exception):
+                    import matplotlib.pyplot as plt
+
+                    plt.show()
 
     return impact
 
@@ -1142,19 +1291,24 @@ def run_synthetic_benchmark(
         if verbose:
             print(f"Cluster ready: {n_workers} workers. Running {operation!r} × {repeats} …")
 
-        for i in range(repeats):
-            t0 = time.monotonic()
-            try:
-                op_fn(arr).compute()
-            except Exception as e:
-                errors.append(f"Run {i + 1} failed: {e}")
-                times.append(float("inf"))
-            else:
-                times.append(time.monotonic() - t0)
+        with _sample_peak_memory(client) as mem_samples:
+            for i in range(repeats):
+                t0 = time.monotonic()
+                try:
+                    op_fn(arr).compute()
+                except Exception as e:
+                    errors.append(f"Run {i + 1} failed: {e}")
+                    times.append(float("inf"))
+                else:
+                    times.append(time.monotonic() - t0)
 
         report = cluster_report(client)
-        peak_mem = report.peak_memory_gib
         spill = report.total_spill_gib
+        if mem_samples["sampled"]:
+            peak_mem = mem_samples["peak_gib"]
+        else:
+            peak_mem = report.peak_memory_gib
+            errors.append("Peak memory sampled after the run; treat it as a lower bound")
 
     except Exception as e:
         errors.append(f"Cluster error: {e}")

{dask_setup-2.1.0 → dask_setup-2.2.0}/src/dask_setup/cli.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import argparse
 import sys
+from dataclasses import replace
 from typing import Any
 
 import yaml
@@ -161,10 +162,14 @@ def cmd_create_profile(args: argparse.Namespace) -> int:
                 print(f" Base profile '{args.from_profile}' not found.", file=sys.stderr)
                 return 1
 
-            # Copy configuration and update name
-            new_config = base_profile.config
-            new_config.name = args.name
-            new_config.description = f"Based on {args.from_profile}"
+            # Copy the configuration -- assigning base_profile.config directly
+            # and then setting .name on it mutates the source profile, which
+            # for a builtin means renaming it for the rest of the process.
+            new_config = replace(
+                base_profile.config,
+                name=args.name,
+                description=f"Based on {args.from_profile}",
+            )
 
             from .config import ConfigProfile