freesolo-flash-dev 1.0.45__tar.gz → 1.0.47__tar.gz

{freesolo_flash_dev-1.0.45 → freesolo_flash_dev-1.0.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 1.0.45
+Version: 1.0.47
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-1.0.45 → freesolo_flash_dev-1.0.47}/flash/engine/worker/heartbeat.py

@@ -84,7 +84,7 @@ _HB_CLAIM_SEQ = 0
 _STEP_GPU_DIAG_INTERVAL_S = 300.0
 _SFT_HEARTBEAT_INTERVAL_S = 60.0
 # retain at least one metric row per second across the 900s training heartbeat throttle window.
-_GRPO_METRIC_HISTORY_LIMIT = 1024
+GRPO_METRIC_HISTORY_LIMIT = 1024
 
 
 def _dump_thread_stacks(reason: str) -> None:
@@ -425,7 +425,7 @@ def make_reward_heartbeat_callback(reward_metrics=None, samples=None):
                     metrics["max_completion_tokens"] = int(max_completion_tokens)
             self.metrics_last = [item for item in self.metrics_last if item["step"] != step]
             self.metrics_last.append(metrics)
-            self.metrics_last = self.metrics_last[-_GRPO_METRIC_HISTORY_LIMIT:]
+            self.metrics_last = self.metrics_last[-GRPO_METRIC_HISTORY_LIMIT:]
             LATEST_GRPO_METRICS_LAST[:] = self.metrics_last
             payload = {
                 **metrics,

{freesolo_flash_dev-1.0.45 → freesolo_flash_dev-1.0.47}/flash/engine/worker/opd_verl.py

@@ -71,6 +71,8 @@ from flash.engine.worker.verl_common import (
     clamp_engine_len,
     latest_global_step_dir,
     model_max_position_embeddings,
+    parse_wandb_link,
+    render_wandb_link_shim,
     resolve_verl_python,
     run_verl_training,
 )
@@ -2344,13 +2346,14 @@ def run_opd_verl(spec=None) -> None:
     entry_path = os.path.join(shim_dir, "flash_opd_verl_entry.py")
     with open(entry_path, "w", encoding="utf-8") as file:
         file.write("import verl\nfrom flash_opd_verl_plugin import main\nmain()\n")
+    opd_shim_source = _render_opd_sitecustomize(
+        save_at_steps=knobs.save_at_steps,
+        total_steps=update_horizon,
+    )
+    if "wandb" in loggers:
+        opd_shim_source += render_wandb_link_shim()
     with open(os.path.join(shim_dir, "sitecustomize.py"), "w", encoding="utf-8") as file:
-        file.write(
-            _render_opd_sitecustomize(
-                save_at_steps=knobs.save_at_steps,
-                total_steps=update_horizon,
-            )
-        )
+        file.write(opd_shim_source)
 
     resume_step, resume_state = _restore_verl_resume(
         local_dir,
@@ -2451,9 +2454,13 @@ def run_opd_verl(spec=None) -> None:
         )
         command = [python_bin, entry_path, *overrides]
         progress = {"step": resume_step, "loss": None}
+        wandb_link: dict[str, str | None] = {}
 
         def on_line(line: str) -> None:
             watcher.raise_if_failed()
+            link = parse_wandb_link(line)
+            if link is not None:
+                wandb_link.update(link)
             step_match = _VERL_STEP_RE.search(line)
             if step_match is None:
                 return
@@ -2669,6 +2676,10 @@ def run_opd_verl(spec=None) -> None:
                 "resumed": bool(resume_step),
                 "wandb_project": project_name if "wandb" in loggers else None,
                 "wandb_run_name": experiment_name if "wandb" in loggers else None,
+                # the sdk's link_wandb reads notes["wandb_url"]; trl gets it from the parent's live
+                # wandb.run, verl from the child marker (see verl_common.render_wandb_link_shim).
+                "wandb_url": wandb_link.get("wandb_url"),
+                "wandb_id": wandb_link.get("wandb_id"),
             },
         )
     finally:

{freesolo_flash_dev-1.0.45 → freesolo_flash_dev-1.0.47}/flash/engine/worker/rl_verl.py

@@ -41,7 +41,11 @@ from flash.engine.structured_outputs import (
     reasoning_parser_for,
 )
 from flash.engine.worker._pkg import W as _w
-from flash.engine.worker.heartbeat import liveness_heartbeat
+from flash.engine.worker.heartbeat import (
+    GRPO_METRIC_HISTORY_LIMIT,
+    LATEST_GRPO_METRICS_LAST,
+    liveness_heartbeat,
+)
 from flash.engine.worker.hf import _deployable_adapter_on_hf
 from flash.engine.worker.perf import gpu_diagnostics, setup_perf_backends, wait_for_gpu
 from flash.engine.worker.rng import backend_seed, seed_training_rngs
@@ -50,8 +54,13 @@ from flash.engine.worker.sft_verl import _hydra_val, _NvidiaSmiPeakSampler
 from flash.engine.worker.verl_common import (
     VERL_REQUIREMENT,
     agent_loop_workers,
+    append_step_metrics,
     clamp_engine_len,
     model_max_position_embeddings,
+    parse_verl_metric,
+    parse_verl_step_metrics,
+    parse_wandb_link,
+    render_wandb_link_shim,
     resolve_verl_python,
     verl_supports_rollout_field,
 )
@@ -370,6 +379,8 @@ def _build_verl_train_notes(
     fp8_kv: bool = False,
     wandb_project: str | None = None,
     wandb_run_name: str | None = None,
+    wandb_url: str | None = None,
+    wandb_id: str | None = None,
 ) -> dict:
     return {
         "backend": "verl",
@@ -419,6 +430,10 @@ def _build_verl_train_notes(
         "ppo_max_token_len_per_gpu": inp["engine_len"],
         "wandb_project": wandb_project,
         "wandb_run_name": wandb_run_name,
+        # the sdk's link_wandb reads notes["wandb_url"]; trl gets it from the parent's live
+        # wandb.run, verl from the child marker (see verl_common.render_wandb_link_shim).
+        "wandb_url": wandb_url,
+        "wandb_id": wandb_id,
         "grpo_recipe": {
             "kl_coef": inp["kl_coef"],
             "entropy_quantile": inp["entropy_quantile"],
@@ -1420,6 +1435,10 @@ def run_rl_verl():
             render_stop_sequences_shim(inp["stop_sequences"]),
             render_structured_outputs_shim(inp["structured_outputs"]),
             render_exact_save_steps_shim(inp["save_at_steps"], inp["steps"]),
+            # gated on the key rather than the resolved logger list: that list needs python_bin,
+            # which is resolved after this file is written. the shim is inert either way -- it only
+            # fires when verl actually calls wandb.init, which requires wandb in the logger list.
+            render_wandb_link_shim() if os.environ.get("WANDB_API_KEY") else "",
         )
         if part
     )
@@ -1433,6 +1452,8 @@ def run_rl_verl():
     # rolling buffer of recent (completion, score) so the training loop can dump one sample per step
     # to the flash log, matching the trl path's #607 per-step completion dump.
     recent_samples: list[tuple[str, float]] = []
+    # filled from the child's marker line; stays empty when wandb is off (see render_wandb_link_shim).
+    wandb_link: dict[str, str | None] = {}
     _samples_lock = threading.Lock()
 
     def _score(index: int, solution_str: str) -> float:
@@ -1544,14 +1565,21 @@ def run_rl_verl():
                 item for item in (shim_dir, os.environ.get("PYTHONPATH", "")) if item
             )
         step_re = re.compile(r"step:\s*(\d+)")
-        reward_re = re.compile(r"critic/rewards/mean:([-\d.eE+]+)")
-        loss_re = re.compile(r"actor/pg_loss:([-\d.eE+]+)")
         reward_history: list[float] = []
-        resp_len_re = re.compile(r"response_length/mean:([\d.eE+-]+)")
         resp_len_history: list[float] = []
         loss_curve: list[float] = []
         last_dump_step = [-1]
-        with liveness_heartbeat("rl_step", progress=_progress, progress_step=True):
+        # per-step backlog for `flash runs log -f`, rebuilt from verl's own step lines because its
+        # trainer runs out of process and cannot host trl's callback. read by the liveness thread
+        # below, so mutate it in place (append_step_metrics) rather than rebinding.
+        metrics_last: list[dict] = []
+        sent_first_metrics = False
+        with liveness_heartbeat(
+            "rl_step",
+            progress=_progress,
+            fields=lambda: {"metrics_last": list(metrics_last)},
+            progress_step=True,
+        ):
             proc = subprocess.Popen(
                 [python_bin, "-m", "verl.trainer.main_ppo", *overrides],
                 stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, env=env_for_verl,
@@ -1560,6 +1588,9 @@ def run_rl_verl():
             try:
                 for line in proc.stdout:
                     print(f"[verl] {line}", end="", flush=True)
+                    link = parse_wandb_link(line)
+                    if link is not None:
+                        wandb_link.update(link)
                     m = step_re.search(line)
                     if m:
                         step_box[0] = int(m.group(1))
@@ -1574,16 +1605,43 @@ def run_rl_verl():
                                     f"[rl-verl] step {step_box[0]} sample (reward={samp[1]:.3f}): {preview}",
                                     flush=True,
                                 )
-                    # capture verl's per-step reward + policy loss for train_meta observability parity.
-                    for pat, sink in (
-                        (reward_re, reward_history),
-                        (loss_re, loss_curve),
-                        (resp_len_re, resp_len_history),
-                    ):
-                        hit = pat.search(line)
-                        if hit:
-                            with contextlib.suppress(ValueError):
-                                sink.append(float(hit.group(1)))
+                    step_metrics = parse_verl_step_metrics(line)
+                    if step_metrics is not None:
+                        # a run constant rather than a verl metric, so it is stamped here the way
+                        # trl's callback reads it off args.max_completion_length.
+                        step_metrics["max_completion_tokens"] = inp["max_completion"]
+                        append_step_metrics(
+                            metrics_last, step_metrics, limit=GRPO_METRIC_HISTORY_LIMIT
+                        )
+                        # the worker's error path reads this global, so a run that dies mid-training
+                        # still reports the steps it did complete (worker/__init__.py:_err_metrics).
+                        LATEST_GRPO_METRICS_LAST[:] = metrics_last
+                        # the rl_train_start ping arms the 900s rl_step throttle, and the liveness
+                        # daemon never forces, so the first backlog would stay invisible for 15
+                        # minutes. force it through the way trl does (heartbeat.py
+                        # force_first_samples), and keep retrying until one commits: the daemon may
+                        # claim this step first, which is fine because its payload carries the same
+                        # backlog. only the FIRST is forced, so the hf commit cap stays protected.
+                        if not sent_first_metrics:
+                            sent_first_metrics = _w.heartbeat(
+                                "rl_step",
+                                force=True,
+                                step=step_metrics["step"],
+                                metrics_last=list(metrics_last),
+                                gpu=gpu_diagnostics(include_torch=False),
+                            )
+                        # per-step series for train_meta observability parity. these live on the same
+                        # line as everything else: verl's only console metric sink is LocalLogger,
+                        # which always prints "step:N - ..." (verl/utils/logger/aggregate_logger.py),
+                        # so a line without a step carries no metric to collect.
+                        for verl_key, sink in (
+                            ("critic/rewards/mean", reward_history),
+                            ("actor/pg_loss", loss_curve),
+                            ("response_length/mean", resp_len_history),
+                        ):
+                            value = parse_verl_metric(line, verl_key)
+                            if value is not None:
+                                sink.append(value)
                 rc = proc.wait()
             except BaseException:
                 # the stream loop died (upload error, cancel, oom in the parent): a still-running
@@ -1631,6 +1689,7 @@ def run_rl_verl():
     with liveness_heartbeat(
         "rl_finalizing",
         progress=lambda: steps_run,
+        fields=lambda: {"metrics_last": list(metrics_last)},
         progress_step=True,
         keepalive=True,
     ):
@@ -1644,7 +1703,13 @@ def run_rl_verl():
         if final_save_due(steps_run, inp["save_at_steps"]):
             _w.publish_deployable_checkpoint(adapter_dir, steps_run)
 
-    _w.heartbeat("rl_trained", train_wall=train_wall, step=steps_run, gpu=gpu_diagnostics())
+    _w.heartbeat(
+        "rl_trained",
+        train_wall=train_wall,
+        step=steps_run,
+        gpu=gpu_diagnostics(),
+        metrics_last=list(metrics_last),
+    )
     _w.write_train_meta(
         phase="rl",
         adapter_dir=adapter_dir,
@@ -1652,6 +1717,7 @@ def run_rl_verl():
         train_wall=train_wall,
         setup_seconds=setup_seconds,
         train_tokens=0,
+        heartbeat_fields={"metrics_last": list(metrics_last)},
         generated_tokens=int(
             sum(resp_len_history) / max(1, len(resp_len_history))
             * steps_run * inp["prompts_per_step"] * inp["group_size"]
@@ -1670,5 +1736,7 @@ def run_rl_verl():
             fp8_kv=fp8_kv,
             wandb_project=project_name if "wandb" in loggers else None,
             wandb_run_name=experiment_name if "wandb" in loggers else None,
+            wandb_url=wandb_link.get("wandb_url"),
+            wandb_id=wandb_link.get("wandb_id"),
         ),
     )

{freesolo_flash_dev-1.0.45 → freesolo_flash_dev-1.0.47}/flash/engine/worker/sft_verl.py

@@ -42,6 +42,8 @@ from flash.engine.worker.sft import (
 from flash.engine.worker.verl_common import (
     export_peft_adapter,
     latest_global_step_dir,
+    parse_wandb_link,
+    render_wandb_link_shim,
     resolve_verl_python,
     run_verl_training,
     stamp_adapter_dir_provenance,
@@ -1282,6 +1284,8 @@ def run_sft_verl(spec=None) -> None:
         total_steps=update_horizon,
         reentrant_gradient_checkpointing=reentrant_gradient_checkpointing,
     )
+    if "wandb" in loggers:
+        shim_source += render_wandb_link_shim()
     with open(os.path.join(shim_dir, "sitecustomize.py"), "w", encoding="utf-8") as file:
         file.write(shim_source)
     with open(custom_dataset_path, "w", encoding="utf-8") as file:
@@ -1327,12 +1331,16 @@ def run_sft_verl(spec=None) -> None:
         resume_step,
     )
     loraplus_applied = resume_step >= update_horizon
+    wandb_link: dict[str, str | None] = {}
 
     def on_line(line: str) -> None:
         nonlocal loraplus_applied
         watcher.raise_if_failed()
         if _LORAPLUS_READY_MARKER in line:
             loraplus_applied = True
+        link = parse_wandb_link(line)
+        if link is not None:
+            wandb_link.update(link)
         step_match = _VERL_STEP_RE.search(line)
         if step_match is None:
             return
@@ -1458,5 +1466,9 @@ def run_sft_verl(spec=None) -> None:
             "ulysses_sequence_parallel_size": gpu_count,
             "wandb_project": project_name if "wandb" in loggers else None,
             "wandb_run_name": experiment_name if "wandb" in loggers else None,
+            # the sdk's link_wandb reads notes["wandb_url"]; trl gets it from the parent's live
+            # wandb.run, verl from the child marker (see verl_common.render_wandb_link_shim).
+            "wandb_url": wandb_link.get("wandb_url"),
+            "wandb_id": wandb_link.get("wandb_id"),
         },
     )

{freesolo_flash_dev-1.0.45 → freesolo_flash_dev-1.0.47}/flash/engine/worker/verl_common.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import contextlib
 import json
+import math
 import os
 import re
 import shutil
@@ -317,3 +318,175 @@ def _kill_process_group(proc: subprocess.Popen) -> None:
         os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
     with contextlib.suppress(subprocess.TimeoutExpired):
         proc.wait(timeout=10)
+
+
+# --------------------------- w&b run link (all three verl backends) ---------------------------
+# trl spreads wandb_run_info() into its notes, giving the sdk's link_wandb a clickable
+# notes["wandb_url"]. verl calls wandb.init INSIDE the training subprocess, so the flash parent's
+# wandb.run is None and that spread would be a silent no-op. the url is not derivable up here
+# either: it needs entity/project/runs/<wandb-generated-id>, and flash only knows the project and
+# its own run NAME. so the child reports it back over the marker channel the parent already scans.
+FLASH_WANDB_LINK_MARKER = "FLASH_WANDB_LINK"
+
+_WANDB_LINK_RE = re.compile(rf"{FLASH_WANDB_LINK_MARKER}\s+(\{{.*\}})\s*$")
+
+
+def render_wandb_link_shim() -> str:
+    """child-side sitecustomize fragment that reports the live w&b run's url and id.
+
+    wraps wandb.init rather than reading wandb.run at import time: sitecustomize runs long before
+    verl's tracking module initializes the run, so anything read here would always be None.
+
+    never raises. wandb is optional and a logging link must not be able to abort paid training, so
+    every failure path leaves the run unlinked instead of dead.
+    """
+    return f'''
+# --- flash: report the w&b run link to the parent (see verl_common.render_wandb_link_shim) ---
+try:
+    import json as _flash_wandb_json
+
+    import wandb as _flash_wandb
+
+    _flash_wandb_init = _flash_wandb.init
+
+    def _flash_wandb_init_reporting(*args, **kwargs):
+        _run = _flash_wandb_init(*args, **kwargs)
+        try:
+            _url = getattr(_run, "url", None)
+            _id = getattr(_run, "id", None)
+            if _url:
+                print(
+                    "{FLASH_WANDB_LINK_MARKER} "
+                    + _flash_wandb_json.dumps({{"wandb_url": _url, "wandb_id": _id}}),
+                    flush=True,
+                )
+        except Exception:
+            pass
+        return _run
+
+    _flash_wandb.init = _flash_wandb_init_reporting
+except Exception:
+    pass
+'''
+
+
+def parse_wandb_link(line: str) -> dict | None:
+    """the {{wandb_url, wandb_id}} a marker line carries, or None for every other line.
+
+    returns None rather than raising on a malformed payload: this parses child stdout, and a
+    truncated or interleaved line under multi-rank logging must not take down the run.
+    """
+    match = _WANDB_LINK_RE.search(line)
+    if match is None:
+        return None
+    try:
+        payload = json.loads(match.group(1))
+    except ValueError:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    url = payload.get("wandb_url")
+    # https only: the sdk renders this as a clickable dashboard link, and child stdout also carries
+    # rollout text, so the field must not be able to become an arbitrary scheme.
+    if not isinstance(url, str) or not url.startswith("https://"):
+        return None
+    wandb_id = payload.get("wandb_id")
+    return {"wandb_url": url, "wandb_id": wandb_id if isinstance(wandb_id, str) else None}
+
+
+# --------------------------- per-step grpo metrics (verl -> `flash runs log -f`) ---------------------------
+# trl feeds `metrics_last` from a TrainerCallback (heartbeat.make_reward_heartbeat_callback), which
+# verl cannot use: its trainer runs out of process. verl's LocalLogger prints exactly one line per
+# optimizer update -- "step:N - key:value - key:value" over every scalar metric -- so the parent
+# reconstructs the same backlog from that line. the payload schema is the CLI's, not verl's: keys
+# below are what flash/cli/commands.py:_FOLLOW_METRIC_FIELDS renders.
+#
+# not anchored at line start: ray tags worker stdout with a "(TaskRunner pid=123) " prefix, so an
+# anchored match would parse nothing at all in production. the existing progress regex in rl_verl
+# is unanchored for the same reason.
+_VERL_STEP_RE = re.compile(r"(?:^|\s)step:(\d+) - ")
+
+# verl metric key -> flash `metrics_last` field. verl has no counterpart for trl's
+# frac_reward_zero_std (an advantage-collapse fraction trl computes per group), so that column is
+# simply absent for verl runs rather than faked; the renderer skips fields it does not find.
+_VERL_METRIC_FIELDS = (
+    ("critic/rewards/mean", "reward"),
+    ("actor/grad_norm", "grad_norm"),
+    ("actor/kl_loss", "kl"),
+    ("actor/entropy", "entropy"),
+    ("response_length/mean", "mean_completion_tokens"),
+    ("response_length/clip_ratio", "truncation_rate"),
+)
+
+# verl reduces most metrics with np.mean and formats them through pprint, so under numpy>=2 a value
+# prints as "np.float32(1.25)" rather than "1.25". verl's own requirements pin numpy<2, but the
+# production interpreter comes from FLASH_VERL_PYTHON (a prebuilt image flash does not own), so
+# accept both spellings -- the numpy-2 form would otherwise drop these columns silently.
+_NUMPY_SCALAR_RE = re.compile(r"^np\.\w+\((.*)\)$")
+
+
+def _metric_value(raw: str) -> float | None:
+    """one verl-printed scalar as a finite float, or None when it is not usable."""
+    wrapper = _NUMPY_SCALAR_RE.match(raw)
+    if wrapper is not None:
+        raw = wrapper.group(1)
+    try:
+        value = float(raw)
+    except ValueError:
+        return None
+    # nan/inf survive float() ("nan", "inf") but would render as a meaningless column and can poison
+    # a json payload downstream, so drop them the way the trl callback does.
+    return value if math.isfinite(value) else None
+
+
+def parse_verl_metric(line: str, verl_key: str) -> float | None:
+    """one verl metric's finite float value from a step line, or None when absent.
+
+    anchors the key on a separator so a metric whose name merely ends with another's
+    (response_length_non_aborted/mean vs response_length/mean) cannot cross-match, and accepts the
+    numpy>=2 ``np.float64(...)`` spelling (see _NUMPY_SCALAR_RE).
+    """
+    hit = re.search(rf"(?:^|[\s-]){re.escape(verl_key)}:(\S+)", line)
+    return None if hit is None else _metric_value(hit.group(1))
+
+
+def parse_verl_step_metrics(line: str) -> dict | None:
+    """the flash `metrics_last` entry a verl step line carries, or None when it carries none.
+
+    returns None rather than raising: this parses child stdout under multi-rank logging, where a
+    truncated or interleaved line must not take down a paid run.
+
+    a step line with no renderable metric yields None rather than a bare ``{"step": n}``: verl logs
+    its pre-training validation pass as its own record at the *current* step counter
+    (ray_trainer.py `logger.log(data=val_metrics, step=self.global_steps)`), and every key on that
+    line is namespaced val-core/ or val-aux/. keeping it would render a row with a step number and
+    no metrics, and -- because the backlog is deduplicated by step -- a resumed run's validation
+    pass would land on the resume step and displace a real training row.
+    """
+    match = _VERL_STEP_RE.search(line)
+    if match is None:
+        return None
+    metrics: dict[str, float | int] = {}
+    for verl_key, flash_key in _VERL_METRIC_FIELDS:
+        value = parse_verl_metric(line, verl_key)
+        if value is not None:
+            metrics[flash_key] = value
+    if not metrics:
+        return None
+    return {"step": int(match.group(1)), **metrics}
+
+
+def append_step_metrics(backlog: list[dict], metrics: dict, *, limit: int) -> None:
+    """record one step in a bounded, de-duplicated backlog, mirroring the trl callback.
+
+    verl reprints a step on a validation pass, and a resumed run replays its resume step, so a
+    repeat must replace rather than append -- otherwise the CLI renders the same step twice.
+
+    the heartbeat thread reads ``backlog`` while the stdout loop writes it, so the new contents are
+    published in ONE slice assignment: a filter/append/truncate sequence would let that reader
+    observe a torn intermediate state with the step momentarily missing.
+    """
+    step = metrics.get("step")
+    kept = [item for item in backlog if item.get("step") != step]
+    kept.append(metrics)
+    backlog[:] = kept[-limit:]

{freesolo_flash_dev-1.0.45 → freesolo_flash_dev-1.0.47}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.0.45"
+version = "1.0.47"
 description = "Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI"
 readme = "README.md"
 # RunPod Flash supports Python 3.11-3.12 (not 3.13 yet).
@@ -116,7 +116,7 @@ artifacts = ["flash/py.typed"]
 # auto-published by .github/workflows/publish-dev.yml: a push to `dev` whose version isn't yet on
 # PyPI publishes it; pushes that don't change it find it already published and no-op. So cutting a
 # dev-channel release = bump this (and [project].version) and merge to `dev`.
-version = "1.0.45"
+version = "1.0.47"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]