pycat-napari 1.6.332__tar.gz → 1.6.334__tar.gz

{pycat_napari-1.6.332 → pycat_napari-1.6.334}/CHANGELOG.md

@@ -1,3 +1,54 @@
+## [1.6.334] - 2026-07-24
+### Fixed + Added — **Navigator execution-adapter layer, Phase 3: adapters fire on REAL plan steps; cell segmentation is the next route-proven workflow.**
+**The finding this closes:** Phase 1 proved the executor mechanism against a *synthetic* step name
+(`background_removal`), but real compiled plans emit toolbox-**module** step names (`segmentation_tools`,
+`image_processing_tools`, …) — so that adapter never fired in production: every real plan step reported
+"run from your panel". Phase 3 re-keys the adapters on the real module names and adds the next proven workflow.
+- **Adapters now key on the real navigator module names** `execution_order` reports. `image_processing_tools`
+  (the module whose product is a background-corrected field) maps to the proven `background_removal` batch step
+  — Phase 1's bit-for-bit proof is now *live* on real plans.
+- **New route-proven workflow: single-frame cell segmentation.** `segmentation_tools` for a **cell** target maps
+  to `cellpose_segmentation` — the batch step `test_route_equivalence` proves computes identically to the manual
+  route. A **coarse** module resolves its batch step from the intent: condensate segmentation resolves to `None`
+  (its batch route is an unproven documented gap) and is reported, never guessed; time-series cell segmentation
+  (`ts_cellpose_tools`, keyframe propagation) is deliberately unmapped — a single-frame stand-in would be wrong
+  science. `resolve_batch_step(step, intent)` is the single "will this step run" authority, shared by the
+  executor and the parameter review.
+- **Reviewed parameters reach the handler where it actually reads them.** Cellpose reads `cell_diameter` from the
+  `data_instance`, not the params dict — so `params_from(intent, ctx, state, reviewed)` now receives the reviewed
+  values and applies each where the handler reads it (the params dict for `ball_radius`, the `data_instance` for
+  `cell_diameter`); the executor never guesses.
+- **Proof** (`tests/navigator/test_navigator_cellpose_adapter.py`, `base`, 5): a real cell plan's segmentation
+  step resolves to a batch handler (the regression guard for the synthetic-name gap); driving
+  `cellpose_segmentation` through the adapter with a reviewed diameter equals a direct Cellpose call at that
+  diameter, **bit for bit**; condensate/time-series segmentation run nothing and are reported; and every batch
+  step an adapter targets is a real registered handler.
+- **Later** (per the `navigator_execution_adapters` spec): more adapters one workflow at a time, then dock
+  progress + cancel (Phase 4).
+
+## [1.6.333] - 2026-07-24
+### Added — **Navigator execution-adapter layer, Phase 2: an honest parameter review — seeded, editable, provenance-recorded.**
+The navigator asks *what* to do, not *with which parameters* — but a guided run that silently picks a
+rolling-ball radius (or a segmentation method) the user never saw is worse than asking. Phase 2 adds the
+minimal parameter review, Qt-free at its core:
+- New **`navigator/parameters.py`**: each adapter-covered step declares its **material** parameters (the handful
+  the science turns on, not every argument). `build_param_review(plan, ctx)` seeds them by a declared
+  precedence — **a matching preset → a session value → the grounded function default** — never an invented one.
+  `ReviewedStep` generalises the preset `populate-but-never-lock` contract to the no-preset case too: the user
+  may edit any value, and the edit is tracked as **provenance in the exact `PresetApplication.record()` shape**
+  (`preset_key`, `modified_parameters`, `is_modified`, `parameters`), `preset_key=None` when no preset seeded it.
+- **The reviewed values drive the run.** `run_plan(…, params_by_step=, provenance_by_step=)` merges the reviewed
+  values over the adapter's derived params (routing keys like `active_layer` still come from the adapter) and
+  records the provenance onto each ran step's `StepOutcome`. `tests/navigator/test_navigator_parameters.py`
+  (`base`, 9) pins it: an edited rolling-ball radius makes the guided result equal the **manual operation at
+  that radius** — and *not* at the default — so the edit provably reaches the computation.
+- **The dock surfaces it**: the plan view renders an editable "Review parameters" form (a spin/combo per
+  material parameter, seeded, tooltip-documented) above Run; the Run passes the `ParamReview` through
+  `run_plan_via_central_manager`, which also reports which steps ran with modified parameters. A programmatic
+  run with no form still builds a default-seeded review, so provenance is recorded either way.
+- **Later phases** (per the `navigator_execution_adapters` spec): more adapters one workflow at a time (each
+  behind its route-equivalence test), then dock progress + cancel.
+
 ## [1.6.332] - 2026-07-24
 ### Added — **Navigator execution-adapter layer, Phase 1: "Run analysis" computes a plan through the batch handlers, gate-respecting (guided == batch == manual).**
 `selection_scale` Part 2 established there is no uniform "run this op" — but the batch `_STEP_MAP` handlers ARE

{pycat_napari-1.6.332 → pycat_napari-1.6.334}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycat-napari
-Version: 1.6.332
+Version: 1.6.334
 Summary: Python Condensate Analysis Toolbox - A napari-based tool for biomolecular condensate analysis
 Project-URL: Homepage, https://github.com/BanerjeeLab-repertoire/pycat-napari
 Project-URL: Repository, https://github.com/BanerjeeLab-repertoire/pycat-napari

{pycat_napari-1.6.332 → pycat_napari-1.6.334}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pycat-napari"
-version = "1.6.332"
+version = "1.6.334"
 description = "Python Condensate Analysis Toolbox - A napari-based tool for biomolecular condensate analysis"
 readme = "README.md"
 # 3.13 is BLOCKED UPSTREAM, not by PyCAT's own code (which compiles and passes core on 3.13).

{pycat_napari-1.6.332 → pycat_napari-1.6.334}/src/pycat/central_manager.py

@@ -124,7 +124,7 @@ class CentralManager:
         from pycat.ui.navigator_dock import install_navigator_action, run_plan_via_central_manager
         self._navigator_action = install_navigator_action(
             self.viewer, central_manager=self,
-            on_run=lambda plan: run_plan_via_central_manager(self, plan))
+            on_run=lambda plan, review=None: run_plan_via_central_manager(self, plan, review))
         # Populate the feature registry so any consumer (the beginner home dock, a capability query) sees
         # every surfaced-but-otherwise-hidden feature (navigator inc 4). Guarded: a registration hiccup must
         # never break startup, and the cards' openers import Qt/toolbox lazily so this stays cheap.

pycat_napari-1.6.334/src/pycat/navigator/executor.py

@@ -0,0 +1,231 @@
+"""**Execute a compiled navigator plan by driving the BATCH step handlers** (execution-adapter layer, Phase 1).
+
+`selection_scale` Part 2 established there is no uniform "run this op" — PyCAT operations have bespoke,
+panel-collected signatures. But the **batch `_STEP_MAP` handlers** are the proven "same computation" route:
+they share one signature — ``(state, image_path, params, output_dir)`` — and `test_route_equivalence` already
+asserts they compute byte-identically to the manual GUI route. So the executor drives *those* handlers, in the
+gate-respecting order (`execution.execution_order`), threading each step's output through a shared ``state``
+dict exactly as a batch replay does.
+
+The narrow bridge is per-step: an :class:`ExecAdapter` maps a plan step to a batch handler and derives that
+handler's ``params`` from the answers. A plan step with **no adapter is reported** ("run it from its method
+panel"), never invoked with guessed arguments — a `fn(image)` fallback would pass wrong args and produce wrong
+science silently, which is the whole reason this is an adapter layer and not a loop over ``resolve_operation``.
+
+Phase 1 ships the executor + registry + ONE proven adapter (``background_removal`` — the shortest chain
+`test_route_equivalence` already covers), so `guided == batch == manual` is pinned; later phases add adapters
+one workflow at a time, each earning its place with a route-equivalence test. Qt-free; a runner is optional
+(off-thread when given, synchronous otherwise)."""
+from __future__ import annotations
+
+import dataclasses
+import pathlib
+import tempfile
+from typing import Callable, Optional
+
+from .execution import execution_order
+
+
+@dataclasses.dataclass(frozen=True)
+class ExecAdapter:
+    """Bridges ONE plan step to the batch handler that computes it. ``plan_step`` is the **real navigator module
+    name** (as `execution_order` reports it — e.g. ``segmentation_tools``, ``image_processing_tools``), not a
+    synthetic label. ``batch_step`` is either the ``_STEP_MAP`` key that computes it, or a callable
+    ``(intent) -> Optional[str]`` for a coarse module whose batch step depends on the target (e.g.
+    ``segmentation_tools`` → ``cellpose_segmentation`` for a cell, ``None`` for a condensate whose batch route is
+    an unproven gap). ``params_from(intent, ctx, state, reviewed)`` derives the handler's ``params`` from the
+    answers and the user-reviewed values, applying each where the handler actually reads it."""
+    plan_step: str
+    batch_step: object
+    params_from: Callable
+
+
+def _background_removal_params(intent, ctx, state, reviewed):
+    radius = reviewed.get("ball_radius") if reviewed else None
+    if radius is None and ctx is not None:
+        try:
+            radius = ctx.get("ball_radius")
+        except Exception:      # broad-ok: optional_probe — a context miss falls back to the grounded default
+            radius = None
+    return {"ball_radius": int(radius) if radius else 50, "active_layer": "segmentation image"}
+
+
+def _cellpose_params(intent, ctx, state, reviewed):
+    """Cellpose reads ``cell_diameter`` from the ``data_instance`` (NOT the params dict), so a reviewed/derived
+    diameter is applied THERE — the params dict only carries the method + refine flag the handler reads."""
+    diam = reviewed.get("cell_diameter") if reviewed else None
+    if diam is None and ctx is not None:
+        try:
+            diam = ctx.get("cell_diameter")
+        except Exception:      # broad-ok: optional_probe — no session diameter → the handler's grounded default (100)
+            diam = None
+    if diam is not None and isinstance(state, dict):
+        di = state.get("data_instance")
+        if di is not None and hasattr(di, "set_data"):
+            try:
+                di.set_data("cell_diameter", int(diam))
+            except Exception:      # broad-ok: optional_probe — a bad diameter falls back to the handler default
+                pass
+    return {"method": "cellpose", "cellpose_refine": False}
+
+
+def _cellpose_step_if_cell(intent):
+    """``segmentation_tools`` is coarse — for a cell target it is single-frame Cellpose (the ``cellpose_segmentation``
+    batch step `test_route_equivalence` proves), but condensate segmentation is an unproven batch route (a
+    documented route-equivalence gap), so it resolves to ``None`` (reported, never guessed). Time-series cell
+    segmentation (``ts_cellpose_tools``) is deliberately NOT mapped: its real operation is keyframe propagation
+    across a stack (``replay_ts_cellpose_keyframe``), which is not route-proven — a single-frame stand-in would
+    be wrong science, so it stays 'run from its panel'."""
+    return "cellpose_segmentation" if getattr(intent, "target", None) == "cell" else None
+
+
+#: The declared adapters, keyed by the REAL navigator module name `execution_order` reports. The ONLY place a
+#: plan step is tied to a computation — a step absent here (or one whose batch step resolves to ``None``) is
+#: reported "run from its panel", never guessed at. Grows one workflow per phase, each behind a
+#: route-equivalence test: ``background_removal`` (rolling-ball) and ``cellpose_segmentation`` are the batch
+#: steps `test_route_equivalence` proves compute identically to the manual route.
+_ADAPTERS: dict = {
+    "image_processing_tools": ExecAdapter("image_processing_tools", "background_removal",
+                                          _background_removal_params),
+    "segmentation_tools": ExecAdapter("segmentation_tools", _cellpose_step_if_cell, _cellpose_params),
+}
+
+
+def has_adapter(step_name: str) -> bool:
+    return step_name in _ADAPTERS
+
+
+def resolve_batch_step(step_name: str, intent=None) -> Optional[str]:
+    """The batch step ``step_name`` will actually run for ``intent``, or ``None`` if it has no adapter or its
+    variant is not auto-runnable yet (a coarse module whose target has no proven batch route). The single
+    authority for 'will this step run', shared by the executor and the parameter review."""
+    adapter = _ADAPTERS.get(step_name)
+    if adapter is None:
+        return None
+    bs = adapter.batch_step
+    return bs(intent) if callable(bs) else bs
+
+
+@dataclasses.dataclass(frozen=True)
+class StepOutcome:
+    """What happened to one step. ``outcome`` is ``'ran'`` / ``'ran_with_caveat'`` / ``'blocked'`` (the run
+    stops here) / ``'skipped'`` (after a blocker) / ``'needs_panel'`` (no adapter yet) / ``'error'``.
+    ``provenance`` (Phase 2) records how the step was parameterised — the ``PresetApplication.record()`` shape
+    (which preset, if any, seeded it and what the user changed) — empty when the step carried no review."""
+    name: str
+    outcome: str
+    detail: str = ""
+    provenance: dict = dataclasses.field(default_factory=dict)
+
+
+@dataclasses.dataclass
+class ExecReport:
+    steps: list = dataclasses.field(default_factory=list)
+
+    @property
+    def ran(self) -> list:
+        return [s for s in self.steps if s.outcome.startswith("ran")]
+
+    @property
+    def stopped(self) -> bool:
+        return any(s.outcome in ("blocked", "error") for s in self.steps)
+
+    @property
+    def needs_panel(self) -> list:
+        return [s for s in self.steps if s.outcome == "needs_panel"]
+
+
+def _build_step_registry() -> dict:
+    """The production batch step registry (name → replay handler), built the way `BatchProcessor` does. Only
+    the import-clean `batch_step_registry` is touched (no Qt)."""
+    registry: dict = {}
+
+    class _Recorder:
+        def register_step(self, name, fn):
+            registry[name] = fn
+
+    from pycat.batch_step_registry import register_all_steps
+    register_all_steps(_Recorder())
+    return registry
+
+
+def run_plan(plan, state, *, intent=None, ctx=None, image_path=None, output_dir=None, runner=None,
+             params_by_step: Optional[dict] = None, provenance_by_step: Optional[dict] = None,
+             on_step: Optional[Callable] = None) -> ExecReport:
+    """Execute ``plan``'s steps in gate order by driving the batch handlers, threading ``state`` (a dict the
+    handlers read/write, exactly as a batch replay). Returns an :class:`ExecReport`.
+
+    Gate semantics are READ from :func:`execution.execution_order`, never re-decided: a **blocker** stops the
+    run at that step (nothing after it runs); a **caveat** runs with the caveat recorded; **probes** run first.
+    A step with no :class:`ExecAdapter` is reported ``'needs_panel'`` — never invoked with guessed arguments.
+    A step that raises halts the run (downstream depends on its output). ``runner`` (an ``OperationRunner``)
+    runs each handler off the Qt thread when given; otherwise handlers run synchronously (headless / tests).
+
+    ``params_by_step`` (Phase 2) overrides the adapter's derived params per step with the user-reviewed values
+    (:mod:`pycat.navigator.parameters`); ``provenance_by_step`` records how each ran step was parameterised
+    (the ``PresetApplication.record()`` shape) onto its :class:`StepOutcome`."""
+    intent = intent if intent is not None else getattr(plan, "intent", None)
+    registry = _build_step_registry()
+    report = ExecReport()
+
+    tmp = None
+    if output_dir is None:
+        tmp = tempfile.TemporaryDirectory()
+        output_dir = pathlib.Path(tmp.name)
+    if image_path is None:
+        image_path = pathlib.Path(output_dir) / "sample.tif"
+
+    try:
+        halted = False
+        for es in execution_order(plan):
+            if halted or es.status == "skipped":
+                report.steps.append(StepOutcome(es.name, "skipped", es.reason))
+                continue
+            if es.status == "blocked":
+                report.steps.append(StepOutcome(es.name, "blocked", es.reason))
+                halted = True
+                continue
+
+            adapter = _ADAPTERS.get(es.name)
+            batch_step = adapter.batch_step(intent) if (adapter and callable(adapter.batch_step)) \
+                else (adapter.batch_step if adapter else None)
+            if batch_step is None:
+                # No adapter, or a coarse module whose variant has no proven batch route yet — report it,
+                # never invoke with guessed arguments.
+                detail = ("no execution adapter yet — run this step from its method panel" if adapter is None
+                          else "this variant isn't auto-runnable yet — run this step from its method panel")
+                report.steps.append(StepOutcome(es.name, "needs_panel", detail))
+                if on_step:
+                    on_step(report.steps[-1])
+                continue
+
+            fn = registry.get(batch_step)
+            if fn is None:
+                report.steps.append(StepOutcome(es.name, "error",
+                                                f"batch step {batch_step!r} is not registered"))
+                halted = True
+                continue
+
+            # Reviewed values reach the adapter, which applies each where the handler actually reads it (the
+            # params dict, or the data_instance for cellpose's cell_diameter) — the executor never guesses.
+            reviewed = (params_by_step or {}).get(es.name, {})
+            params = adapter.params_from(intent, ctx, state, reviewed)
+            try:
+                if runner is not None:
+                    runner.execute(fn, state, image_path, params, output_dir)
+                else:
+                    fn(state, image_path, params, output_dir)
+            except Exception as exc:      # broad-ok: scientific_result — a failed step halts; report it, never silently continue on stale state
+                report.steps.append(StepOutcome(es.name, "error", f"{type(exc).__name__}: {exc}"))
+                halted = True
+                continue
+
+            prov = (provenance_by_step or {}).get(es.name, {})
+            report.steps.append(StepOutcome(
+                es.name, "ran_with_caveat" if es.status == "caveat" else "ran", es.reason, prov))
+            if on_step:
+                on_step(report.steps[-1])
+    finally:
+        if tmp is not None:
+            tmp.cleanup()
+    return report

pycat_napari-1.6.334/src/pycat/navigator/parameters.py

@@ -0,0 +1,201 @@
+"""**The minimal parameter review — surface the handful of parameters that change the result, seeded honestly.**
+
+Execution-adapter layer, Phase 2. The navigator asks *what* to do, not *with which parameters* — but a guided
+run that silently picks a rolling-ball radius (or a segmentation method) the user never saw is worse than
+asking. So before a run, each adapter-covered step surfaces its **material** parameters — the handful that
+materially change the result — in a small editable set, seeded by a declared precedence:
+
+1. **A matching preset** (:mod:`pycat.utils.analysis_presets`) — if one ``applies_to`` this step's workflow,
+   its parameters seed the values (the populate-but-never-lock contract).
+2. **A session value** — a measured/derived value already in the context (e.g. a ``ball_radius`` the user
+   measured on their data) seeds an un-preset parameter.
+3. **The grounded function default** — the same default the batch handler falls back to; never an invented one.
+
+The user may edit any value; the edit is tracked so the run records **which preset (if any) seeded each step
+and what the user changed** — the exact ``PresetApplication.record()`` shape, so a guided result states how it
+was parameterised and a saved template can carry those params. Qt-free: this is the model the dock's editable
+form and :func:`pycat.navigator.executor.run_plan` both read; the dock only builds widgets over it.
+
+Phase 2 ships the model + the one shipped adapter's material set (``background_removal`` → ``ball_radius``);
+later adapters declare their material params here as they land, each still behind a route-equivalence test."""
+from __future__ import annotations
+
+import dataclasses
+from typing import Optional
+
+from .execution import execution_order
+from .executor import resolve_batch_step
+
+
+@dataclasses.dataclass(frozen=True)
+class StepParam:
+    """One material parameter of a step — declared, so the review shows the same handful the science turns on
+    (not every argument the function takes). ``kind`` is ``'int'`` / ``'float'`` / ``'choice'``; ``default`` is
+    the grounded function default (what the batch handler falls back to), never an invented value."""
+    name: str
+    label: str
+    kind: str
+    default: object
+    choices: tuple = ()
+    help: str = ""
+    minimum: object = None
+    maximum: object = None
+
+
+#: The material parameters per plan step, keyed by the REAL navigator module name. The ONLY place a step
+#: declares which of its arguments are surfaced for review. Grows one adapter at a time (each behind its
+#: route-equivalence test), mirroring ``executor._ADAPTERS``.
+_CELL_DIAMETER = StepParam(
+    "cell_diameter", "Cell diameter (px)", "int", 100, minimum=1,
+    help="The approximate cell diameter in pixels that Cellpose sizes its search to. Measure it on your data — "
+         "a wrong diameter is the most common cause of missed or merged cells. Default 100 px.")
+_MATERIAL: dict = {
+    "image_processing_tools": (
+        StepParam("ball_radius", "Rolling-ball radius (px)", "int", 50, minimum=1,
+                  help="The rolling-ball structuring radius for background estimation. Larger keeps more "
+                       "low-frequency structure; too small eats real signal. Default 50 px."),
+    ),
+    "segmentation_tools": (_CELL_DIAMETER,),
+}
+
+
+#: Plan step → the ``analysis_presets`` workflow id whose presets seed it (preset precedence, source 1). Empty
+#: for the shipped adapter (no preset applies to ``background_removal``); entries land with the adapters that a
+#: preset actually configures (e.g. ``condensate_puncta_refinement``), one per phase.
+_PRESET_WORKFLOW: dict = {}
+
+
+def material_params(step_name: str) -> tuple:
+    """The declared material parameters of ``step_name`` (empty if none/unknown)."""
+    return _MATERIAL.get(step_name, ())
+
+
+def _coerce(param: StepParam, value):
+    """Coerce a value to the parameter's kind, falling back to the default on a bad value (never raise into a
+    run) — an int param must not carry a float that changes ``ceil`` downstream."""
+    try:
+        if param.kind == "int":
+            return int(round(float(value)))
+        if param.kind == "float":
+            return float(value)
+    except (TypeError, ValueError):
+        return param.default
+    return value
+
+
+def _applicable_preset(step_name: str):
+    """The single preset that applies to this step's workflow, or ``None``. If more than one applies we return
+    ``None`` (picking one silently would be dishonest — that is a preset-picker choice, not a default)."""
+    workflow = _PRESET_WORKFLOW.get(step_name)
+    if not workflow:
+        return None
+    try:
+        from pycat.utils.analysis_presets import presets_for
+        applicable = presets_for(workflow)
+    except Exception:      # broad-ok: optional_probe — no preset registry → seed from defaults, not a crash
+        return None
+    return applicable[0] if len(applicable) == 1 else None
+
+
+def _seed_value(param: StepParam, preset, ctx):
+    """Seed one parameter by the declared precedence: preset → session value → grounded default."""
+    if preset is not None and param.name in getattr(preset, "parameters", {}):
+        return _coerce(param, preset.parameters[param.name])
+    if ctx is not None:
+        try:
+            cv = ctx.get(param.name)
+        except Exception:      # broad-ok: optional_probe — a non-mapping context just means no session value
+            cv = None
+        if cv is not None:
+            return _coerce(param, cv)
+    return param.default
+
+
+class ReviewedStep:
+    """One step's reviewable parameters: seeded honestly, editable, tracking the deviation from the seed. The
+    populate-but-never-lock contract of :class:`PresetApplication`, generalised to also cover the no-preset
+    case (``preset_key`` is ``None`` then) — because provenance is owed whether or not a preset seeded it."""
+
+    def __init__(self, step_name: str, params, *, preset=None, ctx=None):
+        self.step_name = step_name
+        self.params = tuple(params)
+        self.preset = preset
+        self._seed = {p.name: _seed_value(p, preset, ctx) for p in self.params}
+        self.values = dict(self._seed)
+        self._modified: set = set()
+
+    def _param(self, name) -> Optional[StepParam]:
+        return next((p for p in self.params if p.name == name), None)
+
+    def set(self, name, value):
+        """Set a value (coerced to its kind); mark it modified iff it differs from the seed. Setting it back to
+        the seeded value clears the modification — a result that matches the seed was not 'modified'."""
+        param = self._param(name)
+        if param is None:
+            return self
+        v = _coerce(param, value)
+        if self._seed.get(name) != v:
+            self._modified.add(name)
+        else:
+            self._modified.discard(name)
+        self.values[name] = v
+        return self
+
+    @property
+    def is_modified(self) -> bool:
+        return bool(self._modified)
+
+    def provenance(self) -> dict:
+        """The recorded provenance — the exact :meth:`PresetApplication.record` shape, with ``preset_key``
+        ``None`` when no preset seeded the step. Travels into the run report and a saved template."""
+        return {"preset_key": self.preset.key if self.preset is not None else None,
+                "modified_parameters": sorted(self._modified),
+                "is_modified": self.is_modified,
+                "parameters": dict(self.values)}
+
+
+class ParamReview:
+    """The reviewable parameter set for a whole plan — the adapter-covered, runnable steps that declare
+    material params, each a :class:`ReviewedStep`. The dock renders an editable form over it; the executor
+    reads :meth:`params_by_step` / :meth:`provenance_by_step`."""
+
+    def __init__(self, steps):
+        self.steps = list(steps)
+
+    @property
+    def is_empty(self) -> bool:
+        return not self.steps
+
+    def step(self, name) -> Optional[ReviewedStep]:
+        return next((s for s in self.steps if s.step_name == name), None)
+
+    def params_by_step(self) -> dict:
+        return {s.step_name: dict(s.values) for s in self.steps}
+
+    def provenance_by_step(self) -> dict:
+        return {s.step_name: s.provenance() for s in self.steps}
+
+
+def build_param_review(plan, ctx=None) -> ParamReview:
+    """Build the reviewable parameter set for ``plan``: one :class:`ReviewedStep` per adapter-covered step that
+    will actually run (``run`` / ``caveat`` in :func:`execution_order`) and declares material params, seeded by
+    the declared precedence. Blocked/skipped steps carry no review (they will not run). Never invents a
+    parameter — a step with no declared material params contributes nothing to review."""
+    reviewed = []
+    intent = getattr(plan, "intent", None)
+    try:
+        order = execution_order(plan)
+    except Exception:      # broad-ok: optional_probe — an un-orderable plan yields an empty review, not a crash
+        order = []
+    for es in order:
+        if es.status not in ("run", "caveat"):
+            continue
+        # Only steps that will ACTUALLY run get a review — a coarse module whose variant is not auto-runnable
+        # (its batch step resolves to None) must not surface a parameter for a step that won't execute.
+        if resolve_batch_step(es.name, intent) is None:
+            continue
+        params = material_params(es.name)
+        if not params:
+            continue
+        reviewed.append(ReviewedStep(es.name, params, preset=_applicable_preset(es.name), ctx=ctx))
+    return ParamReview(reviewed)

{pycat_napari-1.6.332 → pycat_napari-1.6.334}/src/pycat/ui/navigator_dock.py

@@ -128,17 +128,25 @@ def _render_observations(widget, body_layout):
                                  "color: gray; font-size: 10px; margin-bottom: 4px;"))
 
 
-def run_plan_via_central_manager(central_manager, plan):
+def run_plan_via_central_manager(central_manager, plan, review=None):
     """Execute a compiled plan against the session's data through the execution-adapter layer, and report
     per-step outcomes. Adapter-covered steps run through the batch handlers (the proven 'same computation'
-    route); a step with no adapter yet is reported as 'run from its panel' — never invoked with guessed args.
-    Safe on an uncovered plan (nothing runs); best-effort, never crashes the UI. This is the wired ``on_run``."""
+    route) with the user-reviewed parameters (Phase 2); a step with no adapter yet is reported as 'run from its
+    panel' — never invoked with guessed args. ``review`` is the :class:`ParamReview` the dock built from its
+    editable form; when ``None`` (a programmatic run), one is built from the plan so parameters are still
+    preset/default-seeded and provenance is still recorded. Safe on an uncovered plan (nothing runs);
+    best-effort, never crashes the UI. This is the wired ``on_run``."""
     try:
         from pycat.navigator.executor import run_plan
         dr = getattr(getattr(central_manager, "active_data_class", None), "data_repository", None)
         if dr is None:
             return
-        report = run_plan(plan, dr, ctx=dr)
+        if review is None:
+            from pycat.navigator.parameters import build_param_review
+            review = build_param_review(plan, ctx=dr)
+        report = run_plan(plan, dr, ctx=dr,
+                          params_by_step=review.params_by_step(),
+                          provenance_by_step=review.provenance_by_step())
         ran = [s.name for s in report.ran]
         panel = [s.name for s in report.needs_panel]
         blocked = [s for s in report.steps if s.outcome == "blocked"]
@@ -149,6 +157,9 @@ def run_plan_via_central_manager(central_manager, plan):
             parts.append(f"Stopped at {blocked[0].name} — {blocked[0].detail}")
         if panel:
             parts.append("Run these from their method panels, in order: " + ", ".join(panel) + ".")
+        modified = [s.name for s in report.ran if s.provenance.get("is_modified")]
+        if modified:
+            parts.append("Parameters modified for: " + ", ".join(modified) + ".")
         from napari.utils.notifications import show_info
         show_info(" ".join(parts) or "Nothing to run.")
     except Exception as exc:      # broad-ok: ui_cleanup — a run attempt must never crash the guided panel
@@ -199,6 +210,68 @@ def _add_template_save(widget, body_layout):
     body_layout.addWidget(btn)
 
 
+def _param_input(param, value, on_change):
+    """One editable control for a material parameter, seeded at ``value``; ``on_change(new_value)`` fires on
+    edit. int → spin box, float → double spin, choice → combo. Returns the widget (or ``None`` on an odd kind)."""
+    from PyQt5.QtWidgets import QSpinBox, QDoubleSpinBox, QComboBox
+    if param.kind == "int":
+        w = QSpinBox()
+        w.setMinimum(int(param.minimum) if param.minimum is not None else 0)
+        w.setMaximum(int(param.maximum) if param.maximum is not None else 100000)
+        w.setValue(int(value))
+        w.valueChanged.connect(lambda v: on_change(v))
+        return w
+    if param.kind == "float":
+        w = QDoubleSpinBox()
+        w.setDecimals(3)
+        w.setMinimum(float(param.minimum) if param.minimum is not None else 0.0)
+        w.setMaximum(float(param.maximum) if param.maximum is not None else 1e9)
+        w.setValue(float(value))
+        w.valueChanged.connect(lambda v: on_change(v))
+        return w
+    if param.kind == "choice":
+        w = QComboBox()
+        w.addItems([str(c) for c in param.choices])
+        if str(value) in [str(c) for c in param.choices]:
+            w.setCurrentText(str(value))
+        w.currentTextChanged.connect(lambda v: on_change(v))
+        return w
+    return None
+
+
+def _add_param_review(widget, body_layout, plan):
+    """Render the editable parameter-review form (Phase 2) and stash the :class:`ParamReview` on the widget as
+    ``_review`` for the run. Surfaces the handful of material parameters per adapter-covered step, seeded from a
+    preset/session value/grounded default (never invented); an edit is tracked so the run records provenance.
+    Renders nothing when no adapter-covered step has material params — the honest 'nothing to review' case."""
+    from PyQt5.QtWidgets import QFrame, QVBoxLayout, QHBoxLayout
+    from pycat.navigator.parameters import build_param_review, material_params
+    try:
+        review = build_param_review(plan, ctx=widget._session.ctx)
+    except Exception:      # broad-ok: ui_cleanup — a review failure must not break the plan view
+        review = None
+    widget._review = review
+    if review is None or review.is_empty:
+        return
+    body_layout.addWidget(_label("⚙  Review parameters", "font-weight: bold; font-size: 12px; margin-top: 6px;"))
+    body_layout.addWidget(_label("Seeded from your data and grounded defaults — edit before running.",
+                                 "color: gray; font-size: 10px;"))
+    for step in review.steps:
+        body_layout.addWidget(_label(step.step_name, "font-weight: bold; font-size: 11px; color: #2a7ab0;"))
+        for param in material_params(step.step_name):
+            frame = QFrame()
+            row = QHBoxLayout(frame)
+            row.setContentsMargins(0, 0, 0, 0)
+            row.addWidget(_label(param.label, "font-size: 11px;"))
+            inp = _param_input(param, step.values.get(param.name, param.default),
+                               lambda v, s=step, n=param.name: s.set(n, v))
+            if inp is not None:
+                if param.help:
+                    inp.setToolTip(param.help)
+                row.addWidget(inp)
+            body_layout.addWidget(frame)
+
+
 def build_navigator_widget(session, *, on_run=None, central_manager=None, parent=None):
     """Build (do not mount) the Navigator widget over ``session``, or return ``None`` if Qt is unavailable
     (headless). ``on_run(plan)`` is called when the user runs the compiled plan. When ``central_manager`` is
@@ -235,6 +308,7 @@ def build_navigator_widget(session, *, on_run=None, central_manager=None, parent
     widget._rows = []
     widget._choice_buttons = []
     widget._run_button = None
+    widget._review = None               # Phase 2: the ParamReview built at plan render, passed to the run
     widget._regate_only = False         # a viewer event re-gates; answering/restart recompiles
     widget._reeval_pending = False
 
@@ -267,6 +341,7 @@ def build_navigator_widget(session, *, on_run=None, central_manager=None, parent
         body_layout.addWidget(_label(_PLAN_LEGEND, "color: gray; font-size: 10px; margin-bottom: 4px;"))
         for row in widget._rows:
             body_layout.addWidget(_row_frame(row))
+        _add_param_review(widget, body_layout, plan)     # Phase 2: the editable, seeded material params
         run = QPushButton("▶  Run analysis")
         reason = widget._session.run_blocked_reason()
         run.setEnabled(reason is None and callable(widget._on_run))
@@ -289,7 +364,11 @@ def build_navigator_widget(session, *, on_run=None, central_manager=None, parent
 
     def _run():
         if callable(widget._on_run) and widget._plan is not None:
-            widget._on_run(widget._plan)
+            review = getattr(widget, "_review", None)
+            try:
+                widget._on_run(widget._plan, review)     # Phase 2: pass the reviewed params
+            except TypeError:
+                widget._on_run(widget._plan)             # a 1-arg on_run (older callers) still works
 
     def _restart():
         widget._session = NavigatorSession()