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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horus-runtime
-Version: 0.2.0
+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.0 → horus_runtime-0.2.2}/pyproject.toml

@@ -65,6 +65,7 @@ local = "horus_builtin.target.local"
 
 [project.entry-points."horus.task"]
 horus_task = "horus_builtin.task.horus_task"
+subworkflow = "horus_builtin.workflow.subworkflow.expander"
 
 [project.entry-points."horus.transfer"]
 local_to_local = "horus_builtin.transfer.local_noop"

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

@@ -139,6 +139,10 @@ _SECONDS_PER_MINUTE = 60
 _LOG_LINES = 8
 _TRANSFER_LINGER_S = 2.0
 
+# Live refresh rate. The spinner advances at this same rate so its animation
+# can't beat against the frame rate.
+_REFRESH_HZ = 8
+
 
 class _LogLine(NamedTuple):
     """One rendered entry in the log/event pane."""
@@ -161,7 +165,8 @@ def _make_console() -> Console:
 
 def _spinner_frame() -> str:
     """Pick a spinner glyph from the wall clock (animates via Live refresh)."""
-    return _SPINNER_FRAMES[int(time.monotonic() * 10) % len(_SPINNER_FRAMES)]
+    tick = int(time.monotonic() * _REFRESH_HZ)
+    return _SPINNER_FRAMES[tick % len(_SPINNER_FRAMES)]
 
 
 def _fmt_duration(seconds: float | None) -> str:
@@ -238,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.
@@ -263,23 +269,44 @@ 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]:
         """Drive the Rich ``Live`` dashboard for the ``with`` body.
 
+        Runs on the terminal's alternate screen (``screen=True``) so Rich
+        diffs frames into a dedicated buffer instead of erasing and repainting
+        scrollback lines, which is what made the display flicker as the
+        dashboard's height changed between frames.
+
         Redirects loguru's terminal sink into the log pane for the duration so
         log lines never corrupt the display, restoring it on exit.
         """
@@ -290,8 +317,9 @@ class WorkflowTUISubscriber(BaseEventSubscriber):
             with Live(
                 view,
                 console=self._console,
-                refresh_per_second=8,
+                refresh_per_second=_REFRESH_HZ,
                 transient=False,
+                screen=True,
             ) as live:
                 self._live = live
                 try:
@@ -301,11 +329,12 @@ class WorkflowTUISubscriber(BaseEventSubscriber):
                     raise
                 finally:
                     self._live = None
-                    # Final repaint so terminating statuses (and any error
-                    # panel) are shown before Live tears down.
-                    live.update(view)
         finally:
             horus_logger.restore_terminal()
+            # The alternate screen is gone by now, so leave a receipt of the
+            # final state behind in normal scrollback. Runs on the failure
+            # path too, so a crash still reports what happened.
+            self._console.print(self._render_summary())
 
     def handle(self, event: BaseEvent) -> None:
         """React to bus events: pause for interactions, feed the log pane."""
@@ -458,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)
@@ -564,6 +593,40 @@ class WorkflowTUISubscriber(BaseEventSubscriber):
             body, title=_("Failed"), border_style="red", padding=(0, 1)
         )
 
+    def _render_summary(self) -> RenderableType:
+        """One-line receipt of the final state, for normal scrollback.
+
+        The dashboard lives on the alternate screen and disappears when Live
+        tears down, so this is all the user is left with after a run.
+        """
+        workflow = self._workflow
+        if workflow is None:
+            return Text(_("No workflow ran."), style="dim")
+
+        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 = (
+            None
+            if self._started_at is None
+            else time.monotonic() - self._started_at
+        )
+        line = Text.assemble(
+            (workflow.name, "bold"),
+            ("  ·  ", "dim"),
+            (
+                workflow.status.value.upper(),
+                _WF_STATUS_STYLE.get(workflow.status, "white"),
+            ),
+            ("  ·  ", "dim"),
+            (f"{done}/{len(tasks)} " + _("tasks"), "dim"),
+            ("  ·  ", "dim"),
+            (_fmt_duration(elapsed), "dim"),
+        )
+        if self._error is None:
+            return line
+        return Group(line, self._render_error())
+
 
 def render_workflow(workflow: BaseWorkflow, trigger_id: str) -> None:
     """

{horus_runtime-0.2.0 → horus_runtime-0.2.2}/src/horus_builtin/runtime/python_script.py

@@ -25,6 +25,9 @@ from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar
 
 from horus_builtin.runtime.command import CommandRuntime
+from horus_builtin.runtime.substitution import (
+    is_template as _is_template,
+)
 from horus_builtin.runtime.substitution import substitute
 from horus_runtime.context import HorusContext
 from horus_runtime.core.runtime.events import RuntimeEvent
@@ -67,16 +70,32 @@ class PythonScriptRuntime(CommandRuntime):
     command: str = ""
 
     def anchor_local_paths(self, base: Path) -> None:
-        """Resolve ``script`` against ``base`` if it is a relative path."""
+        """
+        Resolve ``script`` against ``base`` if it is a relative path.
+
+        A templated script (see :meth:`_setup_runtime`) names an artifact
+        rather than a file on this machine, so it is left untouched.
+        """
+        if _is_template(self.script):
+            return
         if not self.script.is_absolute():
             self.script = (base / self.script).resolve()
 
     async def _setup_runtime(self, task: "BaseTask") -> str:
-        remote_path = f"{task.working_dir}/{self.script.name}"
-
-        # Placing the file also creates task.working_dir on the target, which
-        # the executor uses as cwd and where the script's outputs land.
-        await task.target.put_file(self.script, remote_path)
+        if _is_template(self.script):
+            # ``script: ${my_script}`` names an input artifact instead of a
+            # file on the orchestrator. The transfer layer has already placed
+            # it on the target, so resolve its on-target path and skip the
+            # upload -- the orchestrator may not have the file at all (this is
+            # how tc-os runs an imported workflow).
+            remote_path = substitute(str(self.script), task)
+            await task.target.mkdir(task.working_dir)
+        else:
+            remote_path = f"{task.working_dir}/{self.script.name}"
+
+            # Placing the file also creates task.working_dir on the target,
+            # which the executor uses as cwd and where the outputs land.
+            await task.target.put_file(self.script, remote_path)
 
         args = substitute(self.args, task) if self.args else ""
         cmd = f"{self.python} {shlex.quote(remote_path)} {args}".rstrip()

{horus_runtime-0.2.0 → horus_runtime-0.2.2}/src/horus_builtin/runtime/substitution.py

@@ -42,6 +42,8 @@ from typing import TYPE_CHECKING
 from horus_runtime.i18n import tr as _
 
 if TYPE_CHECKING:
+    from pathlib import PurePath
+
     from horus_runtime.core.artifact.base import BaseArtifact
     from horus_runtime.core.target.base import BaseTarget
     from horus_runtime.core.task.base import BaseTask
@@ -122,6 +124,21 @@ class _Resolver(Mapping[str, str]):
         return len(self._roots)
 
 
+def is_template(value: "str | PurePath") -> bool:
+    """
+    True if *value* carries a ``$`` placeholder and so must be rendered by
+    :func:`substitute` against a task rather than used verbatim.
+
+    Fields that normally hold a path on the orchestrator (a script, a conda
+    environment file) accept ``${artifact_id}`` instead, naming an input
+    artifact that the transfer layer has already placed on the target. That
+    lets a workflow run on a machine that never had the original file.
+
+    ``$$`` is the escape for a literal ``$`` and does not make a template.
+    """
+    return "$" in str(value).replace("$$", "")
+
+
 def substitute(template: str, task: "BaseTask") -> str:
     """
     Render *template* against *task* using ``string.Template`` ``$``/``${}``