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

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

@@ -1,3 +1,25 @@
+## [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
+the proven "same computation" route (uniform `(state, image_path, params, output_dir)`; `test_route_equivalence`
+asserts batch == manual). This ships the executor that drives them:
+- New Qt-free **`navigator/executor.py`**: `run_plan(plan, state, …)` executes a compiled plan by driving the
+  batch handlers in the gate-respecting order (`execution.execution_order`), threading each step's output
+  through a shared `state` as a batch replay does. An `ExecAdapter` maps a plan step to a batch handler and
+  derives its params; **a step with no adapter is reported ('needs_panel'), never invoked with guessed
+  arguments** — the whole point of an adapter layer over a generic `fn(image)` (which would produce wrong
+  science silently). Gate semantics are READ from `execution_order`: a blocker halts the run (state untouched),
+  a caveat runs with its reason, probes first.
+- **One proven adapter (`background_removal`)** — the shortest chain `test_route_equivalence` covers — so the
+  acceptance gate is pinned: `tests/navigator/test_navigator_executor.py` (`base`, 5) asserts **guided == batch
+  == manual, bit for bit**, plus a blocker halts + leaves state untouched, a caveat runs, and an uncovered step
+  is reported not invoked.
+- **The Run button is wired** (`run_plan_via_central_manager`, passed as `on_run` from `central_manager`):
+  adapter-covered steps run through the batch handlers; uncovered steps are reported "run these from their
+  method panels, in order". Safe on an uncovered plan (nothing runs); best-effort.
+- **Later phases** (per the `navigator_execution_adapters` spec): a parameter-review panel, more adapters one
+  workflow at a time (each behind its own route-equivalence test), and dock progress/cancel.
+
 ## [1.6.331] - 2026-07-24
 ### Added — **Save an answered guided plan as a reusable method template (selection_scale Part 3).**
 The navigator's payoff: a plan the user likes should be reusable on other data without re-answering. A guided

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycat-napari
-Version: 1.6.331
+Version: 1.6.332
 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.331 → pycat_napari-1.6.332}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pycat-napari"
-version = "1.6.331"
+version = "1.6.332"
 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.331 → pycat_napari-1.6.332}/src/pycat/central_manager.py

@@ -119,9 +119,12 @@ class CentralManager:
             getattr(self.menu_manager, 'file_menu', None),
             getattr(getattr(self.viewer, 'window', None), '_qt_window', None))
         # Navigator: guided-analysis dock (question flow -> quality-gated, editable plan). Entry point here,
-        # not the line-capped menu god-file. on_run is left None until the plan-execution bridge lands.
-        from pycat.ui.navigator_dock import install_navigator_action
-        self._navigator_action = install_navigator_action(self.viewer, central_manager=self)
+        # not the line-capped menu god-file. Run analysis is wired through the execution-adapter layer (Phase
+        # 1): adapter-covered steps run via the batch handlers, the rest are reported "run from your panel".
+        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))
         # 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.332/src/pycat/navigator/executor.py

@@ -0,0 +1,163 @@
+"""**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. ``params_from(intent, ctx, state)`` derives
+    the handler's ``params`` from the answers (Phase 1: grounded defaults; a preset seed lands in Phase 2)."""
+    plan_step: str
+    batch_step: str
+    params_from: Callable
+
+
+def _background_removal_params(intent, ctx, state):
+    radius = None
+    try:
+        radius = ctx.get("ball_radius") if ctx is not None else None
+    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"}
+
+
+#: The declared adapters. The ONLY place a plan step is tied to a computation — a step absent here is reported
+#: as "run from its panel", never guessed at. Grows one workflow per phase (each behind a route-equivalence test).
+_ADAPTERS: dict = {
+    "background_removal": ExecAdapter("background_removal", "background_removal", _background_removal_params),
+}
+
+
+def has_adapter(step_name: str) -> bool:
+    return step_name in _ADAPTERS
+
+
+@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'``."""
+    name: str
+    outcome: str
+    detail: str = ""
+
+
+@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,
+             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)."""
+    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)
+            if adapter is None:
+                report.steps.append(StepOutcome(
+                    es.name, "needs_panel", "no execution adapter yet — run this step from its method panel"))
+                if on_step:
+                    on_step(report.steps[-1])
+                continue
+
+            fn = registry.get(adapter.batch_step)
+            if fn is None:
+                report.steps.append(StepOutcome(es.name, "error",
+                                                f"batch step {adapter.batch_step!r} is not registered"))
+                halted = True
+                continue
+
+            params = adapter.params_from(intent, ctx, state)
+            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
+
+            report.steps.append(StepOutcome(
+                es.name, "ran_with_caveat" if es.status == "caveat" else "ran", es.reason))
+            if on_step:
+                on_step(report.steps[-1])
+    finally:
+        if tmp is not None:
+            tmp.cleanup()
+    return report

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

@@ -128,6 +128,34 @@ def _render_observations(widget, body_layout):
                                  "color: gray; font-size: 10px; margin-bottom: 4px;"))
 
 
+def run_plan_via_central_manager(central_manager, plan):
+    """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``."""
+    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)
+        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"]
+        parts = []
+        if ran:
+            parts.append("Ran: " + ", ".join(ran) + ".")
+        if blocked:
+            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) + ".")
+        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
+        from pycat.utils.general_utils import debug_log
+        debug_log("navigator: run_plan_via_central_manager failed", exc)
+
+
 def _guided_run_note(plan):
     """The honest guided-run message, made ACTIONABLE with the gate-respecting run ORDER. Auto-running the
     whole plan needs a per-operation execution adapter (PyCAT ops have bespoke, panel-collected signatures —