iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/screens/main/workflow_content.py

@@ -0,0 +1,248 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Workflow tab content loading, fenced to the session and view that requested it."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass, replace
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from chrys.app.tui.widgets.workflow import text
+from chrys.app.tui.widgets.workflow.output import WorkflowOutputText
+from chrys.app.tui.widgets.workflow.records import stored_output_value
+from chrys.service.workflows.artifacts import read_node_output, read_run_source
+from chrys.service.workflows.discovery import read_entry_bytes
+from chrys.service.workflows.layout import run_dir
+from chrys.service.workflows.store import read_run_header, read_run_output, read_run_spec
+
+if TYPE_CHECKING:
+    from chrys.app.tui.i18n import LocaleController
+    from chrys.app.tui.widgets.workflow.info import WorkflowInfoData
+    from chrys.app.tui.widgets.workflow.panel import WorkflowPanel
+    from chrys.app.tui.widgets.workflow.projector import ObservedRun
+    from chrys.orchestration.workflows.preview import WorkflowPreview
+
+
+@dataclass(frozen=True, slots=True)
+class _View:
+    directory: Path | None
+    run_id: str
+    preview: WorkflowPreview | None
+
+
+class WorkflowContent:
+    def __init__(
+        self,
+        *,
+        panel: WorkflowPanel,
+        session_dir: Callable[[], Path | None],
+        spawn: Callable[[Coroutine[Any, Any, None]], asyncio.Task[None]],
+        refresh: Callable[[], None],
+        show_error: Callable[[str], None],
+        check_preview: Callable[[], object],
+        locale: LocaleController | None,
+    ) -> None:
+        self._panel = panel
+        self._session_dir = session_dir
+        self._spawn = spawn
+        self._refresh = refresh
+        self._show_error = show_error
+        self._check_preview = check_preview
+        self._locale = locale
+        self._source_generation = 0
+        self._source_error: tuple[_View, str] | None = None
+        self._output_run: ObservedRun | None = None
+        self._outputs: tuple[WorkflowOutputText, ...] | None = None
+        self._info_view: _View | None = None
+        self._info_data: WorkflowInfoData | None = None
+        self._closed = False
+
+    def reset(self) -> None:
+        """Release cached content and invalidate reads from the previous view."""
+        self._source_generation += 1
+        self._source_error = None
+        self._output_run = None
+        self._outputs = None
+        self._info_view = None
+        self._info_data = None
+
+    def close(self) -> None:
+        self._closed = True
+        self.reset()
+
+    def invalidate_source(self) -> None:
+        self._source_generation += 1
+
+    def _view(self) -> _View:
+        panel = self._panel
+        # Saved artifacts belong to the selected run, regardless of the next-run preview.
+        return _View(self._session_dir(), panel.run_id, None if panel.run_id else panel.preview)
+
+    def _is_current(self, view: _View) -> bool:
+        panel, current = self._panel, self._view()
+        return (
+            not self._closed
+            and panel.is_attached
+            and view.directory == self._session_dir()
+            and view.run_id == panel.run_id
+            and view.preview is current.preview
+        )
+
+    def view_changed(self) -> None:
+        self.invalidate_source()
+        panel = self._panel
+        if panel.code_visible and not (panel.empty or panel.previewing):
+            self._spawn(self._load_source(self._view(), self._source_generation))
+        self._show_info()
+
+    def _show_info(self) -> None:
+        panel = self._panel
+        if not panel.info_visible or panel.empty or panel.previewing or not panel.run_id:
+            return
+        view = self._view()
+        data = panel.info_data
+        if data is None or data.run_id != view.run_id:
+            return
+        if view != self._info_view:
+            self._info_view = view
+            self._info_data = None
+            self._spawn(self._load_info(view, data))
+        elif self._info_data is not None:
+            panel.info_data = self._info_data
+
+    async def _load_info(self, view: _View, data: WorkflowInfoData) -> None:
+        """Supplement the run's manifest with its saved interpreter and source digest."""
+
+        def read() -> WorkflowInfoData:
+            if view.directory is None:
+                raise ValueError(text.render(text.NO_RECORD.bind(), self._locale))
+            directory = run_dir(view.directory, view.run_id)
+            header, spec = read_run_header(directory), read_run_spec(directory)
+            environment = spec.get("environment", {})
+            if not isinstance(environment, dict):
+                raise ValueError("Invalid workflow environment record.")
+            fields = {
+                "source_digest": header.get("entry_digest", ""),
+                "python_version": environment.get("python_version", ""),
+                "environment_mode": environment.get("mode", ""),
+                "interpreter": environment.get("executable", ""),
+            }
+            if not all(isinstance(value, str) for value in fields.values()):
+                raise ValueError("Invalid workflow environment or source digest record.")
+            return replace(data, **fields)
+
+        try:
+            result = await asyncio.to_thread(read)
+        except (OSError, ValueError) as exc:
+            if self._info_view == view and self._is_current(view) and self._panel.info_visible:
+                self._show_error(str(exc))
+            return
+        if self._info_view == view and self._is_current(view):
+            self._info_data = result
+            self._refresh()
+
+    async def _load_source(self, view: _View, generation: int) -> None:
+        if view.preview is None and not view.run_id:
+            return
+
+        def read() -> bytes:
+            if view.run_id:
+                if view.directory is None:
+                    raise ValueError(text.render(text.NO_RECORD.bind(), self._locale))
+                return read_run_source(run_dir(view.directory, view.run_id))
+            if view.preview is None:
+                raise RuntimeError("Reading workflow source requires a run or a preview.")
+            source = view.preview.source
+            return read_entry_bytes(Path(source.canonical_path), source.source_kind)
+
+        def current() -> bool:
+            panel = self._panel
+            return (
+                generation == self._source_generation
+                and self._is_current(view)
+                and not (panel.empty or panel.previewing)
+                and panel.code_visible
+            )
+
+        try:
+            source = await asyncio.to_thread(read)
+        except (OSError, ValueError) as exc:
+            if current() and (view, str(exc)) != self._source_error:
+                self._source_error = (view, str(exc))
+                self._show_error(str(exc))
+            return
+        if current():
+            self._check_preview()
+            self._source_error = None
+            self._panel.show_code(source, differs=view.preview is not None and source != view.preview.source.source)
+            self._refresh()
+
+    def project(self, run: ObservedRun | None) -> None:
+        """Load a terminal result once and paint only the matching run's cached content."""
+        self._show_info()
+        if run is None or run.finished is None:
+            return
+        if self._output_run is not run:
+            self._output_run = run
+            self._outputs = None
+            self._spawn(self._load_outputs(run, self._view()))
+        elif self._outputs is not None:
+            self._panel.show_outputs(self._outputs)
+
+    async def _load_outputs(self, run: ObservedRun, view: _View) -> None:
+        if run.finished is None:
+            raise RuntimeError("Loading workflow outputs requires a finished run.")
+        # Snapshot identities before crossing into a worker thread; live dictionaries
+        # belong to the main pump even when this particular run has finished.
+        outputs = tuple(run.finished.outputs)
+        kinds = {node["id"]: node["kind"] for node in run.started.manifest.get("nodes", [])}
+
+        def read() -> tuple[WorkflowOutputText, ...]:
+            directory = run_dir(view.directory, view.run_id) if view.directory else None
+            parts: list[WorkflowOutputText] = []
+            for output in outputs:
+                try:
+                    value = (
+                        read_node_output(
+                            directory, output.activation_id, output.attempt, node_kind=kinds.get(output.node_id, "")
+                        )
+                        if directory
+                        else None
+                    )
+                    full_text = output.summary_text if value is None else stored_output_value(value)["text"]
+                except (OSError, ValueError) as exc:
+                    # A damaged result must not hide the other output nodes.
+                    parts.append(WorkflowOutputText(output.node_id, str(exc)))
+                else:
+                    parts.append(WorkflowOutputText(output.node_id, full_text, summary_only=value is None))
+            if directory is not None:
+                try:
+                    diagnostics = read_run_output(directory) or {}
+                    for key, label in (("load", text.LOAD_OUTPUT), ("native", text.NATIVE_OUTPUT)):
+                        captured = diagnostics.get(key, {})
+                        captured_text = captured.get("text", "")
+                        dropped = captured.get("dropped_bytes", 0)
+                        if captured.get("truncated") or dropped:
+                            captured_text += "\n" + text.render(text.OUTPUT_TRUNCATED.bind(), self._locale)
+                        if captured_text:
+                            parts.append(WorkflowOutputText(text.render(label.bind(), self._locale), captured_text))
+                    if diagnostics.get("error"):
+                        parts.append(
+                            WorkflowOutputText(
+                                text.render(text.NATIVE_OUTPUT.bind(), self._locale), diagnostics["error"]
+                            )
+                        )
+                except (OSError, ValueError) as exc:
+                    parts.append(WorkflowOutputText(text.render(text.NATIVE_OUTPUT.bind(), self._locale), str(exc)))
+            return tuple(parts)
+
+        try:
+            results = await asyncio.to_thread(read)
+        except (OSError, ValueError) as exc:
+            results = (WorkflowOutputText("", str(exc)),)
+        if self._output_run is run and self._is_current(view):
+            self._outputs = results
+            self._refresh()

chrys/app/tui/screens/main/workflow_controller.py

@@ -0,0 +1,240 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Wire workflow browsing, run control and archived session views to the main screen."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable, Coroutine
+from typing import TYPE_CHECKING, Any
+
+from chrys.app.tui.screens.main.workflow_browser import WorkflowBrowser
+from chrys.app.tui.screens.main.workflow_feedback import WorkflowFeedback
+from chrys.app.tui.screens.main.workflow_run_control import WorkflowRunControl
+from chrys.app.tui.screens.main.workflow_session_view import WorkflowSessionView
+from chrys.app.tui.util.visibility import is_widget_shown_on_active_screen
+from chrys.app.tui.widgets.workflow.projector import INVOCATION_EVENTS, WORKFLOW_EVENTS
+from chrys.foundation.events import types as events
+from chrys.foundation.models.execution import ExecutionSnapshot
+from chrys.foundation.models.workflow_session import WorkflowDraft, WorkspaceSnapshot
+from chrys.foundation.models.workspace import Workspace
+
+if TYPE_CHECKING:
+    from chrys.app.tui.i18n import LocaleController
+    from chrys.app.tui.screens.main.state import MainScreenServices
+    from chrys.app.tui.widgets.workflow.panel import WorkflowPanel
+    from chrys.foundation.i18n import MessageRef
+    from chrys.foundation.models.workflow_session import WorkflowModelSelection
+
+
+class WorkflowController:
+    def __init__(
+        self,
+        *,
+        services: MainScreenServices,
+        panel: WorkflowPanel,
+        cwd: Callable[[], str],
+        schedule: Callable[[Callable[[], None]], bool],
+        sync_chrome: Callable[[], None],
+        locale_controller: LocaleController | None,
+    ) -> None:
+        self.services, self.panel, self.cwd = services, panel, cwd
+        self.schedule, self.sync_chrome = schedule, sync_chrome
+        self.locale_controller = locale_controller
+        self.workflow_mode = False
+        self.closed = False
+        self.generation = 0
+        self._refresh_pending = False
+        # refresh() found the panel displayed but not yet placed on the screen.
+        self._refresh_after_layout = False
+        self._tasks: set[asyncio.Task] = set()
+        self.feedback = WorkflowFeedback(
+            panel=panel,
+            refresh=self.request_refresh,
+            enabled=lambda: self.workflow_mode and not self.closed,
+            locale=locale_controller,
+        )
+        self.browser = WorkflowBrowser(self)
+        self.run_control = WorkflowRunControl(self)
+        self.session_view = WorkflowSessionView(self)
+
+        self._subscriptions: tuple[tuple[type[events.Event], Callable[..., Awaitable[None]]], ...] = (
+            (events.WorkflowModelChangeResult, self.run_control.on_model_result),
+            (events.WorkspaceUpdated, self.browser.on_workspace_updated),
+            (events.WorkflowPreviewProgress, self.browser.on_preview_progress),
+            *((event_type, self.run_control.on_workflow_event) for event_type in WORKFLOW_EVENTS),
+            *((event_type, self.session_view.on_invocation) for event_type in INVOCATION_EVENTS),
+        )
+
+    @property
+    def session_id(self) -> str:
+        selection = self.session_view.selection
+        return selection.session_id if selection is not None else ""
+
+    @property
+    def project_cwd(self) -> str:
+        return self.workspace.primary_cwd
+
+    @property
+    def workspace(self) -> WorkspaceSnapshot:
+        selection = self.session_view.selection
+        return selection.workspace if selection is not None else self.browser.draft.workspace
+
+    @property
+    def model(self) -> WorkflowModelSelection | None:
+        selection = self.session_view.selection
+        return selection.model if selection is not None else self.browser.draft.model
+
+    def new_target(self, workflow_id: str) -> WorkflowDraft:
+        return WorkflowDraft(workflow_id, self.workspace, self.model)
+
+    def new_session_workspace(self) -> WorkspaceSnapshot:
+        return self.current_workspace() if self.session_id else self.browser.draft.workspace
+
+    def current_workspace(self) -> WorkspaceSnapshot:
+        provider = self.services.engine_provider
+        workspace = provider().workspace if provider is not None else None
+        return WorkspaceSnapshot.capture(workspace or Workspace.from_cwd(self.cwd()))
+
+    def execution(self) -> ExecutionSnapshot:
+        return self.services.execution()
+
+    @property
+    def awaiting_engine(self) -> bool:
+        return self.run_control.awaiting_engine
+
+    def show_error(self, message: str | MessageRef) -> None:
+        if not self.closed:
+            self.feedback.notify(message)
+
+    async def subscribe(self) -> None:
+        handle = self.services.settings_handle
+        self.browser.startup_settings = handle.loaded if handle is not None else None
+        for event_type, handler in self._subscriptions:
+            await self.services.bus.subscribe(event_type, handler)
+
+    async def close(self) -> None:
+        self.closed = True
+        self.leave()
+        self.session_view.content.close()
+        for event_type, handler in self._subscriptions:
+            await self.services.bus.unsubscribe(event_type, handler)
+        # Sent requests belong to the engine. Drain their publishers, as well as
+        # cancelled browsing tasks, before releasing the screen's resources.
+        if self._tasks:
+            await asyncio.gather(*self._tasks, return_exceptions=True)
+
+    def leave(self) -> None:
+        self.generation += 1
+        self._refresh_after_layout = False
+        self.browser.leave()
+        self.run_control.leave()
+        self.session_view.leave()
+        self.feedback.clear()
+
+    def enter(self) -> None:
+        self.browser.initialize_draft_model()
+        self.browser.follow_current_workspace()
+        self.browser.refresh_preview_models()
+        self.shown()
+        self.panel.call_after_refresh(self.request_refresh)
+
+    def spawn(self, coroutine: Coroutine[Any, Any, None]) -> asyncio.Task[None]:
+        task = asyncio.create_task(coroutine)
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
+        return task
+
+    def cancel_task(self, task: asyncio.Task) -> None:
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
+        if task is not asyncio.current_task() and not task.done() and not task.cancelling():
+            task.cancel()
+
+    def back(self) -> bool:
+        if self.workflow_mode and not (self.panel.empty or self.panel.previewing) and not self.panel.graph_visible:
+            self.session_view.content.invalidate_source()
+            self.panel.show_graph(focus=True)
+            self.request_refresh()
+            return True
+        if self.browser.preview_flow.active:
+            self.browser.enter_selection()
+            return True
+        return False
+
+    def request_refresh(self) -> None:
+        if self._refresh_pending or self.closed:
+            return
+        self._refresh_pending = self.schedule(self.refresh)
+
+    def tick(self) -> None:
+        if not self.workflow_mode:
+            return
+        panel = self.panel
+        if panel.display and not (panel.empty or panel.previewing):
+            panel.advance_animation(self.session_view.view_run())
+        if (
+            panel.display
+            and not (panel.empty or panel.previewing)
+            and is_widget_shown_on_active_screen(panel)
+            and not self.services.execution_busy()
+            and not self.awaiting_engine
+            and self.browser.check_preview()
+        ):
+            if panel.code_visible and not panel.run_id:
+                self.session_view.content.view_changed()
+            self.request_refresh()
+
+    def refresh(self) -> None:
+        self._refresh_pending = False
+        if self.closed:
+            return
+        panel = self.panel
+        if not panel.is_attached:
+            return
+        self.run_control.refresh_dialogs()
+        self.session_view.refresh_detail()
+        run = self.session_view.view_run()
+        title = run.started.title if run is not None else panel.definition.manifest.get("title", "")
+        panel.set_header(title, session_id=self.session_id, cwd=self.project_cwd or self.cwd())
+        self.sync_chrome()
+        if not panel.display:
+            return
+        if self.browser.picker is not None:
+            self.feedback.present_notice(over=self.browser.picker)
+            return
+        if not is_widget_shown_on_active_screen(panel):
+            # A panel shown from a dialog callback is displayed before the
+            # layout that places it; that layout finishes this refresh.
+            self._refresh_after_layout = True
+            return
+        self._refresh_after_layout = False
+        if self.feedback.present_pending():
+            return
+        execution = self.execution()
+        panel.project(
+            run,
+            busy=self.services.execution_busy(),
+            workflow_active=execution.kind == "workflow" and execution.run_id == panel.run_id,
+            can_stop=self.run_control.can_stop(),
+            starting=bool(self.awaiting_engine) or self.browser.workspace_busy,
+            retry_pending=self.run_control.pending_retries,
+        )
+        self.browser.present_source_warning()
+        panel.show_status(run)
+        self.session_view.content.project(run)
+        self.feedback.present_notice(over=self.browser.picker)
+
+    def screen_layout_refreshed(self) -> None:
+        """Finish a refresh that ran before a screen layout placed the panel."""
+        if self._refresh_after_layout and is_widget_shown_on_active_screen(self.panel):
+            self._refresh_after_layout = False
+            self.request_refresh()
+
+    def shown(self) -> None:
+        self.browser.check_preview(force=True)
+        self.view_changed()
+
+    def view_changed(self) -> None:
+        self.session_view.content.view_changed()
+        self.request_refresh()

chrys/app/tui/screens/main/workflow_feedback.py

@@ -0,0 +1,137 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Workflow notices and progress overlays with one owner for their deferred dismissal."""
+
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from chrys.app.tui.binding_display import CLOSE_BINDING
+from chrys.app.tui.screens.dialogs.agent_load import AgentLoadDialog
+from chrys.app.tui.screens.dialogs.confirm import NoticeDialog
+from chrys.app.tui.widgets.workflow import text
+from chrys.foundation.i18n import MessageRef
+
+if TYPE_CHECKING:
+    from textual.screen import Screen
+
+    from chrys.app.tui.i18n import LocaleController
+    from chrys.app.tui.widgets.workflow.panel import WorkflowPanel
+
+
+_DISMISS_LABEL = CLOSE_BINDING.bind()
+
+
+@dataclass(frozen=True, slots=True)
+class WorkflowNoticeAction:
+    label: MessageRef
+    run: Callable[[], None]
+
+
+@dataclass(frozen=True, slots=True)
+class _Notice:
+    message: str | MessageRef
+    dismiss_label: MessageRef
+    action: WorkflowNoticeAction | None
+
+
+class WorkflowFeedback:
+    def __init__(
+        self,
+        *,
+        panel: WorkflowPanel,
+        refresh: Callable[[], None],
+        enabled: Callable[[], bool],
+        locale: LocaleController | None,
+    ) -> None:
+        self._panel = panel
+        self._refresh = refresh
+        self._enabled = enabled
+        self._locale = locale
+        self.notice: NoticeDialog | None = None
+        self.loading: AgentLoadDialog | None = None
+        self.pending_action: Callable[[], None] | None = None
+        self._notice_text = ""
+        self._pending_notices: deque[_Notice] = deque()
+
+    def render(self, message: str | MessageRef) -> str:
+        return message if isinstance(message, str) else text.render(message, self._locale)
+
+    def notify(
+        self,
+        message: str | MessageRef,
+        *,
+        dismiss_label: MessageRef = _DISMISS_LABEL,
+        action: WorkflowNoticeAction | None = None,
+    ) -> None:
+        if isinstance(message, str):
+            # Error text can carry file names and paths: keep their control characters off the terminal.
+            message = text.shown(message, block=True)
+        rendered = self.render(message)
+        if not rendered or rendered == self._notice_text:
+            return
+        if all(self.render(pending.message) != rendered for pending in self._pending_notices):
+            self._pending_notices.append(_Notice(message, dismiss_label, action))
+            self._refresh()
+
+    def present_notice(self, *, over: Screen | None = None) -> None:
+        panel = self._panel
+        if self.notice is not None or not self._pending_notices or not self._enabled():
+            return
+        if panel.app.screen not in (panel.screen, over):
+            return
+        notice = self._pending_notices.popleft()
+        dialog = NoticeDialog(
+            title=text.TITLE.bind(),
+            message=notice.message,
+            confirm_label=notice.action.label if notice.action is not None else notice.dismiss_label,
+            cancel_label=notice.dismiss_label if notice.action is not None else None,
+            locale_controller=self._locale,
+        )
+        self.notice, self._notice_text = dialog, self.render(notice.message)
+
+        def closed(accepted: bool | None) -> None:
+            if self.notice is dialog:
+                self.notice, self._notice_text = None, ""
+                if accepted and notice.action is not None and self._enabled():
+                    notice.action.run()
+                self._refresh()
+
+        panel.app.push_screen(dialog, closed)
+
+    def clear(self) -> None:
+        self._pending_notices.clear()
+        self.pending_action = None
+        dialog, self.notice = self.notice, None
+        self._notice_text = ""
+        if dialog is not None:
+            dialog.finish()
+        self.close_loading()
+
+    def present_pending(self) -> bool:
+        action, self.pending_action = self.pending_action, None
+        if action is None:
+            return False
+        action()
+        return True
+
+    def close_loading(self) -> None:
+        dialog, self.loading = self.loading, None
+        if dialog is not None:
+            dialog.request_dismiss()
+
+    def show_loading(self, *, title: MessageRef, message: MessageRef, phase: str) -> None:
+        self.close_loading()
+        dialog = AgentLoadDialog(title=title, locale_controller=self._locale)
+        dialog.update_progress(message, phase=phase)
+        self.loading = dialog
+
+        def closed(_result: None) -> None:
+            if self.loading is dialog:
+                self.loading = None
+            self._refresh()
+
+        self._panel.app.push_screen(dialog, closed)

chrys/app/tui/screens/main/workflow_flow.py

@@ -0,0 +1,49 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Cancellation and stale-result fences for one workflow UI flow."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Coroutine
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from chrys.app.tui.screens.main.workflow_controller import WorkflowController
+
+
+type FlowToken = tuple[int, int]
+
+
+class WorkflowFlow:
+    def __init__(self, host: WorkflowController) -> None:
+        self.host = host
+        self.revision = 0
+        self.task: asyncio.Task[None] | None = None
+
+    def current(self, token: FlowToken) -> bool:
+        return not self.host.closed and token == (self.host.generation, self.revision)
+
+    def invalidate(self) -> None:
+        self.revision += 1
+        if self.task is not None:
+            self.host.cancel_task(self.task)
+            self.task = None
+
+    def start(self, operation: Callable[[FlowToken], Coroutine[Any, Any, None]]) -> asyncio.Task[None]:
+        previous = self.task
+        self.invalidate()
+        token = self.host.generation, self.revision
+
+        async def run() -> None:
+            if previous is not None:
+                await asyncio.gather(previous, return_exceptions=True)
+            if self.current(token):
+                await operation(token)
+
+        self.task = self.host.spawn(run())
+        return self.task
+
+    @property
+    def active(self) -> bool:
+        return self.task is not None and not self.task.done()