horus-runtime 0.2.1__tar.gz → 0.2.2__tar.gz

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horus-runtime
-Version: 0.2.1
+Version: 0.2.2
 Summary: The Horus workflow manager runtime. Execute advanced workflows with multi-environment support, HPC integration, automatic artifact management, and more.
 License-File: LICENSE
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/src/horus_builtin/event/tui_subscriber.py

@@ -243,8 +243,9 @@ class WorkflowTUISubscriber(BaseEventSubscriber):
     _live: Live | None = PrivateAttr(default=None)
     _workflow: BaseWorkflow | None = PrivateAttr(default=None)
 
-    # Execution scope (planned task ids) for an honest progress total.
-    _scope: set[str] = PrivateAttr(default_factory=set)
+    # Task the run was triggered from; the execution scope behind the
+    # progress total is re-planned from it on every frame (see _scope_ids).
+    _trigger: str | None = PrivateAttr(default=None)
     _started_at: float | None = PrivateAttr(default=None)
 
     # Per-task timing, derived from status transitions / completion events.
@@ -268,18 +269,34 @@ class WorkflowTUISubscriber(BaseEventSubscriber):
         Render *workflow*'s tasks before the run starts.
         """
         self._workflow = workflow
+        self._trigger = trigger_id or (
+            workflow.tasks[0].id if workflow.tasks else None
+        )
+
+    def _scope_ids(self, workflow: BaseWorkflow) -> set[str]:
+        """
+        Ids in the run's execution scope, re-planned from *workflow*'s
+        current tasks and edges.
+
+        A ``map:`` or ``sub:`` expander adds its clones, and the edges that
+        reach the gather task, only when it runs (see
+        :meth:`~horus_runtime.core.workflow.base.BaseWorkflow.expand`), so a
+        plan frozen before the run undercounts every fan-out: a five-clone
+        loop map reported ``1/1 tasks``. Re-planning per frame counts the
+        DAG as it actually is.
+        """
+        if self._trigger is None:
+            return {t.id for t in workflow.tasks}
         try:
-            target = trigger_id or (
-                workflow.tasks[0].id if workflow.tasks else None
-            )
-            if target is not None:
-                self._scope = set(
-                    execution_plan(
-                        workflow.tasks, trigger_id=target, edges=workflow.edges
-                    )
+            return set(
+                execution_plan(
+                    workflow.tasks,
+                    trigger_id=self._trigger,
+                    edges=workflow.edges,
                 )
+            )
         except Exception:
-            self._scope = {t.id for t in workflow.tasks}
+            return {t.id for t in workflow.tasks}
 
     @contextmanager
     def live(self) -> Iterator[None]:
@@ -470,7 +487,7 @@ class WorkflowTUISubscriber(BaseEventSubscriber):
         return Panel(line, border_style=style, padding=(0, 1))
 
     def _render_progress(self, workflow: BaseWorkflow) -> RenderableType:
-        scope = self._scope or {t.id for t in workflow.tasks}
+        scope = self._scope_ids(workflow)
         total = len(scope)
         tasks = [t for t in workflow.tasks if t.id in scope]
         done = sum(1 for t in tasks if t.status in _TERMINAL)
@@ -586,7 +603,7 @@ class WorkflowTUISubscriber(BaseEventSubscriber):
         if workflow is None:
             return Text(_("No workflow ran."), style="dim")
 
-        scope = self._scope or {t.id for t in workflow.tasks}
+        scope = self._scope_ids(workflow)
         tasks = [t for t in workflow.tasks if t.id in scope]
         done = sum(1 for t in tasks if t.status in _TERMINAL)
         elapsed = (

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/src/horus_builtin/workflow/map.py

@@ -334,7 +334,9 @@ class MapExpander(HorusTask):
                 )
                 self._set_input_path(clone, self.over.index_input, index_path)
 
-            self._set_output_path(clone, gathered_root / str(i))
+            await self._set_output_path(
+                clone, gathered_root / str(i), orchestrator
+            )
 
             clones.append(clone)
             edges.append(
@@ -592,8 +594,31 @@ class MapExpander(HorusTask):
             )
         self._pin_path(artifact, path)
 
-    def _set_output_path(self, clone: BaseTask, path: Path) -> None:
-        """Pin *clone*'s (sole) declared output at *path*."""
+    async def _set_output_path(
+        self, clone: BaseTask, slot_dir: Path, orchestrator: BaseTarget
+    ) -> None:
+        """
+        Pin *clone*'s (sole) declared output under its ``{i}/`` slot dir.
+
+        A :class:`.FolderArtifact` output already names a directory, so it
+        is pinned straight at *slot_dir* (the gather task then sees
+        ``{i}/<whatever the clone wrote>``). Any other output keeps its
+        declared filename, pinned at ``slot_dir / <filename>``; since
+        nothing else creates *slot_dir* for a bare file output, it is
+        created here first (only in this branch -- pre-creating it for a
+        folder output would make the clone look already-complete and skip
+        it on resume).
+
+        A :class:`~horus_builtin.workflow.subworkflow.expander.
+        SubworkflowExpander` clone is a third case: its sole declared
+        output is always a never-written ``FileArtifact`` port placeholder,
+        regardless of what the real inner producer's output kind is. Its
+        own ``_run`` re-points that real producer at wherever the
+        placeholder got pinned (see ``SubworkflowExpander._pin_out_port``),
+        so it is pinned straight at *slot_dir* like a folder output,
+        leaving that re-pointing free to hand the real producer's own
+        declared filename onward.
+        """
         if len(clone.outputs) != 1:
             raise MapConfigurationError(
                 _(
@@ -602,7 +627,20 @@ class MapExpander(HorusTask):
                 )
                 % {"id": self.id}
             )
-        self._pin_path(clone.outputs[0], path)
+        # Imported here, as in BaseWorkflow.sub, to avoid a
+        # base.py <-> map.py <-> expander.py cycle at module load time.
+        from horus_builtin.workflow.subworkflow.expander import (  # noqa: PLC0415
+            SubworkflowExpander,
+        )
+
+        artifact = clone.outputs[0]
+        if isinstance(artifact, FolderArtifact) or isinstance(
+            clone, SubworkflowExpander
+        ):
+            self._pin_path(artifact, slot_dir)
+        else:
+            await orchestrator.mkdir(str(slot_dir))
+            self._pin_path(artifact, slot_dir / artifact.path.name)
 
     @staticmethod
     def _clone_output_id(clone: BaseTask) -> str:
@@ -665,9 +703,30 @@ def lower_map_entry(
         ``(expander_dict, edges)`` — a ``kind: map_expander`` task dict
         ready for ``BaseTask.model_validate``, and any edges (as plain
         dicts) that must accompany it into the workflow's ``edges`` list.
+
+    Raises:
+        MapConfigurationError: If *entry* is missing the ``id`` key, or its
+            ``map`` block is missing ``template`` or ``gather``, or
+            ``gather`` is missing ``task`` or ``input``.
     """
-    task_id = entry["id"]
+    task_id = entry.get("id")
+    if task_id is None:
+        raise MapConfigurationError(
+            _("A task with a 'map' block is missing required key 'id'.")
+        )
     map_block = entry["map"]
+
+    if "template" not in map_block:
+        raise MapConfigurationError(
+            _("Map task '%(id)s' is missing required key 'map.template'.")
+            % {"id": task_id}
+        )
+    if "gather" not in map_block:
+        raise MapConfigurationError(
+            _("Map task '%(id)s' is missing required key 'map.gather'.")
+            % {"id": task_id}
+        )
+
     over_block = map_block.get("over") or {}
     range_value = map_block.get("range")
     index_input = map_block.get("index_input", over_block.get("index_input"))
@@ -681,6 +740,19 @@ def lower_map_entry(
     }
 
     gather_block = map_block["gather"]
+    if not isinstance(gather_block, dict) or "task" not in gather_block:
+        raise MapConfigurationError(
+            _("Map task '%(id)s' 'map.gather' is missing required key 'task'.")
+            % {"id": task_id}
+        )
+    if "input" not in gather_block:
+        raise MapConfigurationError(
+            _(
+                "Map task '%(id)s' 'map.gather' is missing required "
+                "key 'input'."
+            )
+            % {"id": task_id}
+        )
 
     expander: dict[str, Any] = {
         "kind": "map_expander",

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/src/horus_builtin/workflow/scheduler.py

@@ -182,8 +182,21 @@ async def _execute_ready_task(
             await workflow.transfer_artifacts(task, source_map)
 
             # Execute the task on its target and wait for it to finish.
-            await target.dispatch(task)
-            await target.wait()
+            try:
+                await target.dispatch(task)
+                await target.wait()
+            except asyncio.CancelledError:
+                # Cancelling this wrapper also cancels the inner task future
+                # (cancellation propagates through `target.wait()`'s await),
+                # so by now the task has recorded CANCELED and the future is
+                # done; `target.cancel()` would early-return. Call the
+                # executor's kill hook directly so any external process
+                # (container, remote job) that does not die with the
+                # coroutine is terminated. Shielded so a second cancel
+                # cannot abort the kill mid-flight.
+                if task.status is TaskStatus.CANCELED:
+                    await asyncio.shield(task.executor.cancel_execution())
+                raise
         finally:
             task.target = declared_target
             pool.release(declared_target, target)
@@ -379,9 +392,18 @@ async def run_schedule(workflow: BaseWorkflow, trigger_id: str) -> None:
                 )
                 running[wrapper] = task_id
 
-        done, _pending = await asyncio.wait(
-            running, return_when=asyncio.FIRST_COMPLETED
-        )
+        try:
+            done, _pending = await asyncio.wait(
+                running, return_when=asyncio.FIRST_COMPLETED
+            )
+        except asyncio.CancelledError:
+            # Workflow-level cancellation: `asyncio.wait` does not cancel the
+            # tasks it waits on, so propagate the cancel to every in-flight
+            # wrapper (each one kills its executor via `target.cancel()`, see
+            # `_execute_ready_task`) and wait for them to unwind before
+            # re-raising.
+            await _cancel_running(running)
+            raise
 
         failures = _collect_completions(done, running, completed)
         if failures and workflow.failure_policy == "fail_fast":

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/src/horus_builtin/workflow/subworkflow/expander.py

@@ -252,7 +252,7 @@ class SubworkflowExpander(HorusTask):
                     )
                 )
 
-        edges.extend(self._out_port_edges(wf, out_ports))
+        edges.extend(self._out_port_edges(wf, out_ports, by_id))
 
         wf.expand(tasks=tasks, edges=edges, artifacts=artifacts)
         horus_logger.log.debug(
@@ -442,7 +442,10 @@ class SubworkflowExpander(HorusTask):
         )
 
     def _out_port_edges(
-        self, wf: BaseWorkflow, out_ports: list[SubworkflowPort]
+        self,
+        wf: BaseWorkflow,
+        out_ports: list[SubworkflowPort],
+        by_id: dict[str, BaseTask],
     ) -> list[WorkflowEdge]:
         """
         Re-emit every parent edge sourcing an out-port from the real inner
@@ -451,12 +454,16 @@ class SubworkflowExpander(HorusTask):
         """
         edges: list[WorkflowEdge] = []
         for port in out_ports:
-            if port.task is None or _is_pinned(self.outputs, port.name):
+            if port.task is None:
+                continue
+            if _is_pinned(self.outputs, port.name):
                 # An enclosing construct (a MapExpander materializing this
-                # clone's slot) has taken the port over and consumes the
-                # placeholder directly. Known gap: fan-in of a mapped
-                # subworkflow's results therefore sees the placeholder
-                # rather than the inner producer's real output.
+                # clone's slot) has taken the port over and pinned the
+                # placeholder to the slot's absolute path. Point the real
+                # inner producer's output at that same path instead, so
+                # the slot receives the clone's actual result rather than
+                # the never-written placeholder.
+                self._pin_out_port(by_id, port)
                 continue
             for edge in wf.edges:
                 if edge.source != self.id or edge.source_output != port.name:
@@ -487,6 +494,33 @@ class SubworkflowExpander(HorusTask):
                 )
         return edges
 
+    def _pin_out_port(
+        self, by_id: dict[str, BaseTask], port: SubworkflowPort
+    ) -> None:
+        """
+        Point the real inner producer's output artifact at the absolute
+        path an enclosing construct pinned *port*'s placeholder to.
+
+        Mirrors the "pinned" branch of :meth:`_resolve_in_port`: instead of
+        the placeholder, the actual producer now writes directly to the
+        slot the enclosing construct materialized, so it is filled with
+        the real result rather than staying empty.
+        """
+        assert port.task is not None
+        producer = by_id.get(self._prefixed(port.task))
+        if producer is None:
+            return
+        artifact = next(
+            (a for a in producer.outputs if a.id == port.artifact), None
+        )
+        placeholder = next(
+            (a for a in self.outputs if a.id == port.name), None
+        )
+        if artifact is None or placeholder is None:
+            return
+        assert placeholder.declared_path is not None
+        _pin(artifact, placeholder.declared_path)
+
 
 def _is_pinned(artifacts: list[BaseArtifact], port_name: str) -> bool:
     """Whether *port_name*'s placeholder was pinned to an absolute path."""

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/src/horus_builtin/workflow/subworkflow/lowering.py

@@ -21,6 +21,9 @@ YAML sugar lowering for the subworkflow construct.
 
 from typing import Any
 
+from horus_builtin.workflow.subworkflow.errors import SubworkflowError
+from horus_runtime.i18n import tr as _
+
 
 def lower_subworkflow_entry(entry: dict[str, Any]) -> dict[str, Any]:
     """
@@ -37,8 +40,20 @@ def lower_subworkflow_entry(entry: dict[str, Any]) -> dict[str, Any]:
     Returns:
         A ``kind: subworkflow`` task dict ready for
         ``BaseTask.model_validate``.
+
+    Raises:
+        SubworkflowError: If *entry* is missing the ``id`` or ``sub`` key.
     """
-    task_id = entry["id"]
+    task_id = entry.get("id")
+    if task_id is None:
+        raise SubworkflowError(
+            _("A task with a 'sub' block is missing required key 'id'.")
+        )
+    if "sub" not in entry:
+        raise SubworkflowError(
+            _("Subworkflow task '%(id)s' is missing required key 'sub'.")
+            % {"id": task_id}
+        )
     data: dict[str, Any] = {
         "kind": "subworkflow",
         "id": task_id,

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/src/horus_runtime/core/workflow/base.py

@@ -253,12 +253,11 @@ class BaseWorkflow(AutoRegistry, entry_point="workflow"):
     _revision: int = PrivateAttr(default=0)
     """
     Monotonically increasing counter for the workflow's DAG structure
-    (tasks/edges/artifacts). Nothing bumps it yet: today the DAG is fixed for
-    the lifetime of a run, so it is built once and stays at ``0``. It exists
-    so a future dynamic-DAG feature (fan-out/map/loops) can increment it when
-    mutating the graph mid-run, and the scheduler's cached source map (see
-    :meth:`cached_source_map`) picks up the change without any changes to the
-    scheduler itself.
+    (tasks/edges/artifacts). Bumped by :meth:`add_task`, :meth:`add_edge`,
+    :meth:`add_artifact` and :meth:`expand` whenever the graph mutates
+    mid-run (e.g. a dynamic fan-out/map/loop expansion), so the scheduler's
+    cached source map (see :meth:`cached_source_map`) picks up the change
+    without any changes to the scheduler itself.
     """
 
     @model_validator(mode="before")

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/src/horus_runtime/core/workflow/exceptions.py

@@ -27,8 +27,15 @@ if TYPE_CHECKING:
     from horus_runtime.core.workflow.base import BaseWorkflow
 
 
-class WorkflowError(Exception):
-    """Base exception for workflow-related errors."""
+class WorkflowError(ValueError):
+    """
+    Base exception for workflow-related errors.
+
+    Derives from :class:`ValueError` so that any subclass raised inside a
+    Pydantic validator (e.g. ``BaseWorkflow``'s ``model_validator`` hooks)
+    is automatically wrapped into a :class:`pydantic.ValidationError` by
+    Pydantic, instead of escaping as a raw, unwrapped exception.
+    """
 
 
 class OneWorkflowAtATimeError(WorkflowError):

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/src/horus_runtime/sanitize.py

@@ -40,9 +40,13 @@ the comments and the executor anchor that these files are written around.
 """
 
 import re
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from pathlib import Path
 
+import yaml
+
+from horus_builtin.workflow.map import MapExpander
+from horus_runtime.core.artifact.base import BaseArtifact
 from horus_runtime.core.workflow.base import BaseWorkflow
 
 
@@ -55,17 +59,31 @@ class RootInput:
     """An unwired task input, and the root artifact it would be promoted to."""
 
     root_id: str
-    """Id for the new root artifact."""
-
-    kind: str
-    """Artifact kind, copied from the task input."""
+    """Id for the new root artifact; differs from the input's own id only
+    when that id is already taken (see :func:`_root_id`)."""
 
-    path: Path
-    """Workflow-relative path, exactly as declared."""
+    artifact: BaseArtifact
+    """
+    The task input being promoted, kept whole rather than field-by-field so
+    every declared field (name, description, and whatever a plugin artifact
+    kind adds) travels to the root artifact without this module knowing it.
+    """
 
     consumers: tuple[tuple[str, str], ...]
     """``(task_id, input_id)`` pairs to wire, one edge each."""
 
+    @property
+    def path(self) -> Path:
+        """Workflow-relative path, exactly as declared."""
+        declared = self.artifact.declared_path
+        assert declared is not None  # only set for inputs with a declared path
+        return declared
+
+    @property
+    def kind(self) -> str:
+        """Artifact kind, as declared on the task input."""
+        return self.artifact.kind
+
 
 @dataclass(frozen=True)
 class MissingEdge:
@@ -119,6 +137,14 @@ def find_root_inputs(
         for edge in workflow.edges
         if edge.target_input is not None
     }
+    # A map's fan-in input is wired by MapExpander at run time, not by a
+    # static edge, so it would otherwise look like an author-supplied root
+    # input and get promoted to one.
+    wired |= {
+        (task.gather_task, task.gather_input)
+        for task in workflow.tasks
+        if isinstance(task, MapExpander)
+    }
     # Reuses the runtime's own produced-vs-external rule rather than
     # restating it here, so sanitizing can never drift from packaging.
     produced = workflow._produced_declared_paths()  # noqa: SLF001
@@ -151,13 +177,12 @@ def find_root_inputs(
                 )
                 continue
             # One file consumed by several tasks travels as one root
-            # artifact with one edge per consumer.
+            # artifact with one edge per consumer; the first consumer's
+            # declaration is the one promoted.
             existing = by_path.get(declared)
             if existing is not None:
-                by_path[declared] = RootInput(
-                    root_id=existing.root_id,
-                    kind=existing.kind,
-                    path=existing.path,
+                by_path[declared] = replace(
+                    existing,
                     consumers=(*existing.consumers, (task.id, artifact.id)),
                 )
                 continue
@@ -165,25 +190,41 @@ def find_root_inputs(
             taken.add(root_id)
             by_path[declared] = RootInput(
                 root_id=root_id,
-                kind=artifact.kind,
-                path=declared,
+                artifact=artifact,
                 consumers=((task.id, artifact.id),),
             )
 
     return sorted(by_path.values(), key=lambda r: r.path), missing
 
 
+def _artifact_block(root: RootInput) -> list[str]:
+    """Render one promoted artifact, with every field the author declared."""
+    # exclude_defaults keeps the block to what the author actually wrote. id
+    # and path are then overridden: the model holds the artifact's own id
+    # (the root may have been renamed to avoid a clash) and a CWD-resolved
+    # absolute path (see BaseArtifact.resolve_path), neither of which belongs
+    # in a portable workflow file.
+    data = root.artifact.model_dump(mode="json", exclude_defaults=True)
+    data["id"] = root.root_id
+    data["path"] = root.path.as_posix()
+    data.setdefault("kind", root.kind)  # kind is a default on every subclass
+    # default_name assigns name = id after validation, so an unset name
+    # survives exclude_defaults as an echo of the id, carrying nothing the
+    # id doesn't already say.
+    if data.get("name") == root.artifact.id:
+        data.pop("name")
+    block = yaml.safe_dump([data], sort_keys=False, allow_unicode=True)
+    # Blank lines occur inside a quoted multi-line scalar, where they are the
+    # line break itself; indenting them would only add trailing whitespace.
+    return [f"  {line}" if line else "" for line in block.splitlines()] + [""]
+
+
 def _render(root_inputs: list[RootInput]) -> tuple[list[str], list[str]]:
     """Render the ``artifacts:`` entries and ``edges:`` entries to insert."""
     artifacts: list[str] = []
     edges: list[str] = []
     for root in root_inputs:
-        artifacts += [
-            f"  - id: {root.root_id}",
-            f"    kind: {root.kind}",
-            f"    path: {root.path.as_posix()}",
-            "",
-        ]
+        artifacts += _artifact_block(root)
         for task_id, input_id in root.consumers:
             edges += [
                 f"  - source: artifact-{root.root_id}",
@@ -228,22 +269,23 @@ def apply_promotions(text: str, root_inputs: list[RootInput]) -> str:
     artifact_lines, edge_lines = _render(root_inputs)
     keys = _top_level_keys(lines)
 
-    if "edges" not in keys:
-        raise SanitizeError(
-            "Workflow has no top-level 'edges:' block to extend."
-        )
-
     # Insert the later block first so the earlier block's index stays valid.
-    edges_at = _block_end(lines, keys["edges"], keys)
-    lines[edges_at:edges_at] = ["", *edge_lines] if edge_lines else []
+    if "edges" in keys:
+        edges_at = _block_end(lines, keys["edges"], keys)
+        lines[edges_at:edges_at] = ["", *edge_lines] if edge_lines else []
+    else:
+        # A map:-only workflow has no top-level edges: block of its own (the
+        # map block describes all its wiring); create one at the end.
+        lines += ["", "edges:", *edge_lines]
 
     if "artifacts" in keys:
         at = _block_end(lines, keys["artifacts"], keys)
         lines[at:at] = artifact_lines
     else:
         # Root inputs read best above the tasks that consume them; fall back
-        # to the edges block for a workflow with no tasks key of its own.
-        anchor = keys.get("tasks", keys["edges"])
+        # to the edges block (just created above if it didn't already
+        # exist) for a workflow with no tasks key of its own.
+        anchor = keys.get("tasks", keys.get("edges", len(lines)))
         lines[anchor:anchor] = ["artifacts:", *artifact_lines]
 
     return "\n".join(lines) + "\n"

{horus_runtime-0.2.1 → horus_runtime-0.2.2}/tests/unit/event/test_tui_subscriber.py

@@ -34,6 +34,7 @@ from horus_runtime.core.interaction.transport import (
 )
 from horus_runtime.core.task.base import BaseTask
 from horus_runtime.core.task.status import TaskStatus
+from horus_runtime.core.workflow.edge import WorkflowEdge
 from horus_runtime.event.subscriber import BaseEventSubscriber
 
 
@@ -116,6 +117,37 @@ class TestWorkflowTUISubscriber:
             tui.handle(answered)
             assert tui._paused is False
 
+    def test_progress_total_follows_a_growing_dag(self) -> None:
+        """
+        Tasks added after ``track()`` count towards the total.
+
+        A ``map:``/``sub:`` expander only adds its clones once it runs, so a
+        scope planned before the run reported ``1/1 tasks`` for a five-clone
+        loop map.
+        """
+        wf = _workflow()
+        wf.edges.append(WorkflowEdge(source="a", target="b"))
+        tui = WorkflowTUISubscriber()
+        tui.track(wf, trigger_id="a")
+
+        console = Console(record=True, width=120)
+        console.print(tui.render())
+        assert "0/2 " in console.export_text()
+
+        wf.tasks.append(
+            HorusTask(
+                id="c",
+                name="Gamma",
+                runtime=CommandRuntime(command="true"),
+                executor=ShellExecutor(),
+            )
+        )
+        wf.edges.append(WorkflowEdge(source="b", target="c"))
+
+        console = Console(record=True, width=120)
+        console.print(tui.render())
+        assert "0/3 " in console.export_text()
+
     def test_setup_is_noop(self) -> None:
         """setup() is a no-op and must not raise."""
         WorkflowTUISubscriber().setup()