zrb 0.28.1__py3-none-any.whl → 1.0.0a8__py3-none-any.whl

zrb/runner/web_controller/task_ui/partial/visualize-history.js

@@ -0,0 +1,104 @@
+function visualizeHistory(allTaskStatus, finished) {
+    const taskNames = Object.keys(allTaskStatus);
+    const now = Date.now();
+
+    // Set up canvas context
+    const canvas = document.getElementById("history-canvas");
+    canvas.height = taskNames.length * 50 + 10;
+    const ctx = canvas.getContext("2d");
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    ctx.fillStyle = "#EEE";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+
+    // Calculate start and end times
+    let minDateTime = null;
+    let maxDateTime = null;
+    for (let taskName in allTaskStatus) {
+        let history = allTaskStatus[taskName].history;
+        if (history.length == 0) {
+            continue;
+        }
+        let startTime = new Date(history[0].time);
+        if (minDateTime === null || minDateTime > startTime) {
+            minDateTime = startTime;
+        }
+        let lastTime = new Date(history[history.length - 1].time);
+        if (maxDateTime === null || maxDateTime < lastTime) {
+            maxDateTime = lastTime;           
+        }
+    }
+    if (minDateTime === null || maxDateTime === null) {
+        return
+    }
+    if (!finished) {
+        maxDateTime = now;
+    }
+    if (maxDateTime - minDateTime == 0) {
+        maxDateTime.setSeconds(maxDateTime.getSeconds() + 1) 
+    }
+    // Canvas settings
+    const chartWidth = canvas.width;
+    const barHeight = 20;
+    const gap = 10;
+    const timeScale = (chartWidth - 200) / (maxDateTime - minDateTime);
+
+    // Draw labels and bars
+    taskNames.forEach((taskName, index) => {
+        const taskHistories = allTaskStatus[taskName].history;
+        if (taskHistories.length == 0) {
+            return
+        }
+        // Get last status
+        const finalStatus = getFinalTaskStatus(allTaskStatus[taskName]);
+        const startDateTime = new Date(taskHistories[0].time);
+        const endDateTime = getTaskEndDateTime(allTaskStatus[taskName], now);
+        const startX = 100 + (startDateTime - minDateTime) * timeScale;
+        const barWidth = (endDateTime - startDateTime) * timeScale;
+        const startY = index * (barHeight + gap + 20) + 5;
+
+        // Draw task label
+        ctx.fillStyle = "#000";
+        ctx.font = "12px Arial";
+        ctx.textAlign = "right";
+        ctx.fillText(taskName, 90, startY + barHeight / 1.5);
+
+        // Draw task bar
+        ctx.fillStyle = getFinalColor(finalStatus);
+        ctx.fillRect(startX, startY, barWidth, barHeight);
+
+        ctx.fillStyle = "#000";
+        ctx.textAlign = "left";
+        // Combine captions if time overlap
+        let labels = {};
+        for (let taskHistory of taskHistories) {
+            let status = taskHistory.status;
+            let dateTime = new Date(taskHistory.time);
+            let statusStartX = 100 + (dateTime - minDateTime) * timeScale;
+            if (!(statusStartX in labels)) {
+                labels[statusStartX] = {dateTime: dateTime, caption: status};
+            } else {
+                labels[statusStartX].caption += `, ${status}`
+            }
+        }
+        // Draw start and end time below the bar
+        for (let statusStartX in labels) {
+            const {dateTime, caption} = labels[statusStartX];
+            const [dateStr, timeStr] = dateTime.toISOString().split("T");
+            ctx.font = "10px Arial";
+            ctx.fillText(caption, statusStartX, startY + 10);
+            ctx.font = "8px Arial";
+            ctx.fillText(dateStr, statusStartX, startY + barHeight + 10);
+            ctx.fillText(timeStr, statusStartX, startY + barHeight + 20);
+        }
+    });
+}
+
+function getTaskEndDateTime(taskStatus, now) {
+    if (taskStatus.is_completed || taskStatus.is_terminated || taskStatus.is_skipped || taskStatus.is_permanently_failed) {
+        histories = taskStatus.history;
+        if (histories.length > 0) {
+            return new Date(histories[histories.length - 1].time);
+        }
+    }
+    return now;
+}

zrb/runner/web_controller/task_ui/view.html

@@ -0,0 +1,87 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="color-scheme" content="light dark">
+    <link rel="stylesheet" href="/static/pico.min.css">
+    <link rel="icon" href="/static/favicon-32x32.png" sizes="32x32" type="image/png">
+    <title>Zrb</title>
+  </head>
+  <body>
+
+    <header class="container">
+      <hgroup>
+        <h1>{root_name}</h1>
+        <p>{root_description}</p>
+        <nav>
+          <ul>
+            <li><a href="/">🏠 Home</a></li>
+            <li><a href="{parent_url}">🔙 Parent</a></li>
+            <li><a href="{ui_url}">🆕 New Session</a></li>
+            <li><a href="#" onclick="openDialog(event)">📂 Existing Session</a></li>
+          </ul>
+        </nav>
+      </hgroup>
+    </header>
+
+    <dialog id="session-history-dialog">
+      <article>
+        <header>
+          <button aria-label="Close" rel="prev" onclick="closeDialog(event)"></button>
+          <p>
+            <strong>📂 Existing Session</strong>
+          </p>
+        </header>
+        <main>
+          <form>
+            <fieldset class="grid">
+              <input type="datetime-local" id="min-start-at-input" placeholder="Minimum Start Time" aria-label="Minimum Start Time" />
+              <input type="datetime-local" id="max-start-at-input" placeholder="Maximum Start Time" aria-label="Maximum Start Time" />
+            </fieldset>
+          </form>
+          <ul id="session-history-ul" style="font-family:monospace;"></ul>
+        </main>
+        <footer>
+          <nav>
+            <ul id="session-history-pagination-ul"></ul>
+          </nav>
+        </footer>
+      </article>
+    </dialog>
+
+    <main class="container">
+      <h3>{name}</h3>
+      <p>{description}</p>
+      <canvas id="history-canvas" height="0" width="1000" style="width: 100%;"></canvas>
+      <hr />
+      <form id="submit-task-form" onsubmit="submitForm(event)">
+        {task_inputs}
+        <button>🚀 Run</button>
+      </form>
+      <hr />
+      <label>
+        Result
+        <textarea id="result-textarea" rows="1" readonly style="font-family:monospace;">
+        </textarea>
+      </label>
+      <label>
+        Log
+        <textarea id="log-textarea" rows="5" readonly style="font-family:monospace;">
+        </textarea>
+      </label>
+    </main>
+
+  </body>
+  <script>
+    const CURRENT_URL = '{url}';
+    const API_URL = '{api_url}';
+    const UI_URL = `{ui_url}`;
+    let SESSION_NAME = '{session_name}';
+    let PAGE = 0;
+    {main_script} 
+    {common_util_script}
+    {show_existing_session_script}
+    {visualize_history_script}
+  </script>
+</html>

zrb/runner/web_util.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+
+
+class NewSessionResponse(BaseModel):
+    session_name: str
+
+
+def url_to_args(url: str) -> list[str]:
+    stripped_url = url.strip("/")
+    return [part for part in stripped_url.split("/") if part.strip() != ""]
+
+
+def node_path_to_url(args: list[str]) -> str:
+    pruned_args = [part for part in args if part.strip() != ""]
+    stripped_url = "/".join(pruned_args)
+    return f"/{stripped_url}/"

zrb/session/any_session.py

@@ -0,0 +1,196 @@
+from __future__ import annotations  # Enables forward references
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Coroutine, TypeVar
+
+from zrb.context.any_context import AnyContext
+from zrb.group.any_group import AnyGroup
+from zrb.session_state_log.session_state_log import SessionStateLog
+from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
+from zrb.task_status.task_status import TaskStatus
+
+if TYPE_CHECKING:
+    from zrb.context import any_shared_context
+    from zrb.task import any_task
+
+TAnySession = TypeVar("TAnySession", bound="AnySession")
+
+
+class AnySession(ABC):
+    """Abstract base class for managing task execution and context in a session.
+
+    This class handles task lifecycle management, context retrieval,
+    deferred task execution, and data exchange between tasks using
+    XCom-like functionality.
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Name this session"""
+        pass
+
+    @property
+    @abstractmethod
+    def root_group(self) -> AnyGroup | None:
+        """Session root group"""
+        pass
+
+    @property
+    @abstractmethod
+    def task_names(self) -> list[str]:
+        """Task names in this session"""
+        pass
+
+    @property
+    @abstractmethod
+    def shared_ctx(self) -> any_shared_context.AnySharedContext:
+        """Shared context for this session"""
+        pass
+
+    @abstractmethod
+    def terminate(self):
+        """Terminating session"""
+        pass
+
+    @property
+    @abstractmethod
+    def is_terminated(self) -> bool:
+        """Whether session is terminated or not"""
+        pass
+
+    @property
+    @abstractmethod
+    def parent(self) -> TAnySession | None:
+        """Parent session"""
+        pass
+
+    @abstractmethod
+    def task_path(self) -> str:
+        """Main task's path"""
+        pass
+
+    @property
+    @abstractmethod
+    def final_result(self) -> Any:
+        """Main task's result"""
+        pass
+
+    @property
+    @abstractmethod
+    def state_logger(self) -> AnySessionStateLogger:
+        """State logger"""
+        pass
+
+    @abstractmethod
+    def set_main_task(self, main_task: any_task.AnyTask):
+        """Set main task"""
+        pass
+
+    @abstractmethod
+    def as_state_log(self) -> SessionStateLog:
+        pass
+
+    @abstractmethod
+    def get_ctx(self, task: any_task.AnyTask) -> AnyContext:
+        """Retrieves the context for a specific task.
+
+        Args:
+            task (AnyTask): The task for which to retrieve the context.
+
+        Returns:
+            AnyContext: The context object specific to the provided task.
+        """
+        pass
+
+    @abstractmethod
+    def defer_monitoring(self, task: any_task.AnyTask, coro: Coroutine):
+        """Defers the execution of a task's monitoring coroutine for later processing.
+
+        Args:
+            task (AnyTask): The task associated with the coroutine.
+            coro (Coroutine): The monitoring coroutine to defer.
+        """
+        pass
+
+    @abstractmethod
+    def defer_action(self, task: any_task.AnyTask, coro: Coroutine):
+        """Defers the execution of a task's coroutine for later processing.
+
+        Args:
+            task (AnyTask): The task associated with the coroutine.
+            coro (Coroutine): The coroutine to defer.
+        """
+        pass
+
+    @abstractmethod
+    def defer_coro(self, coro: Coroutine):
+        """Defers the execution of a coroutine for later processing.
+
+        Args:
+            coro (Coroutine): The coroutine to defer.
+        """
+        pass
+
+    @abstractmethod
+    async def wait_deferred(self):
+        """Asynchronously waits for all deffered coroutines to complete"""
+        pass
+
+    @abstractmethod
+    def register_task(self, task: any_task.AnyTask):
+        """Registers a new task in the session.
+
+        Args:
+            task (AnyTask): The task to register in the session.
+        """
+        pass
+
+    @abstractmethod
+    def get_root_tasks(self, task: any_task.AnyTask) -> list[any_task.AnyTask]:
+        """Retrieves the list of root tasks that should be executed first
+        to run the given task.
+
+        Args:
+            task (AnyTask): The current task.
+
+        Returns:
+            list[AnyTask]: A list of root tasks.
+        """
+        pass
+
+    @abstractmethod
+    def get_next_tasks(self, task: any_task.AnyTask) -> list[any_task.AnyTask]:
+        """Retrieves the list of tasks that should be executed after the given task.
+
+        Args:
+            task (AnyTask): The current task.
+
+        Returns:
+            list[AnyTask]: A list of tasks that should be executed next.
+        """
+        pass
+
+    @abstractmethod
+    def get_task_status(self, task: any_task.AnyTask) -> TaskStatus:
+        """Get tasks' status.
+
+        Args:
+            task (AnyTask): The task to mark as started.
+
+        Returns:
+            TaskStatus: Task status object
+        """
+        pass
+
+    @abstractmethod
+    def is_allowed_to_run(self, task: any_task.AnyTask):
+        """Determines if the specified task is allowed to run based on its current state.
+
+        Args:
+            task (AnyTask): The task to check.
+
+        Returns:
+            bool: True if the task is allowed to run, False otherwise.
+        """
+        pass

zrb/session/session.py

@@ -0,0 +1,287 @@
+import asyncio
+from typing import Any, Coroutine
+
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.context.context import AnyContext, Context
+from zrb.group.any_group import AnyGroup
+from zrb.session.any_session import AnySession
+from zrb.session_state_log.session_state_log import (
+    SessionStateLog,
+    TaskStatusHistoryStateLog,
+    TaskStatusStateLog,
+)
+from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
+from zrb.session_state_logger.default_session_state_logger import (
+    default_session_state_logger,
+)
+from zrb.task.any_task import AnyTask
+from zrb.task_status.task_status import TaskStatus
+from zrb.util.cli.style import (
+    BLUE,
+    BRIGHT_BLUE,
+    BRIGHT_CYAN,
+    BRIGHT_GREEN,
+    BRIGHT_MAGENTA,
+    BRIGHT_YELLOW,
+    CYAN,
+    GREEN,
+    ICONS,
+    MAGENTA,
+    YELLOW,
+)
+from zrb.util.group import get_node_path
+from zrb.util.string.name import get_random_name
+from zrb.xcom.xcom import Xcom
+
+
+class Session(AnySession):
+    def __init__(
+        self,
+        shared_ctx: AnySharedContext,
+        parent: AnySession | None = None,
+        root_group: AnyGroup | None = None,
+        state_logger: AnySessionStateLogger | None = None,
+    ):
+        self._name = get_random_name()
+        self._root_group = root_group
+        self._state_logger = state_logger
+        self._task_status: dict[AnyTask, TaskStatus] = {}
+        self._upstreams: dict[AnyTask, list[AnyTask]] = {}
+        self._downstreams: dict[AnyTask, list[AnyTask]] = {}
+        self._context: dict[AnyTask, Context] = {}
+        self._shared_ctx = shared_ctx
+        self._shared_ctx.set_session(self)
+        self._parent = parent
+        self._action_coros: dict[AnyTask, Coroutine] = {}
+        self._monitoring_coros: dict[AnyTask, Coroutine] = {}
+        self._coros: list[Coroutine] = []
+        self._colors = [
+            GREEN,
+            YELLOW,
+            BLUE,
+            MAGENTA,
+            CYAN,
+            BRIGHT_GREEN,
+            BRIGHT_YELLOW,
+            BRIGHT_BLUE,
+            BRIGHT_MAGENTA,
+            BRIGHT_CYAN,
+        ]
+        self._icons = ICONS
+        self._color_index = 0
+        self._icon_index = 0
+        self._is_terminated = False
+        self._main_task: AnyTask | None = None
+        self._main_task_path: list[str] = []
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        name = self.name
+        status = self._task_status
+        shared_ctx = self.shared_ctx
+        return f"<{class_name} name={name} status={status}, shared_ctx={shared_ctx}>"
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def root_group(self) -> AnyGroup | None:
+        return self._root_group
+
+    @property
+    def task_names(self) -> list[str]:
+        return [task.name for task in self._task_status.keys()]
+
+    @property
+    def shared_ctx(self) -> AnySharedContext:
+        return self._shared_ctx
+
+    def terminate(self):
+        self._is_terminated = True
+        for task_status in self._task_status.values():
+            task_status.mark_as_terminated()
+
+    @property
+    def is_terminated(self) -> bool:
+        return self._is_terminated
+
+    @property
+    def parent(self) -> AnySession | None:
+        return self._parent
+
+    @property
+    def task_path(self) -> str:
+        return self._main_task_path
+
+    @property
+    def final_result(self) -> Any:
+        xcom: Xcom = self.shared_ctx.xcom[self._main_task.name]
+        try:
+            return xcom.peek()
+        except IndexError:
+            return None
+
+    @property
+    def state_logger(self) -> AnySessionStateLogger:
+        if self._state_logger is None:
+            return default_session_state_logger
+        return self._state_logger
+
+    def set_main_task(self, main_task: AnyTask):
+        self.register_task(main_task)
+        self._main_task = main_task
+        main_task_path = get_node_path(self._root_group, main_task)
+        self._main_task_path = [] if main_task_path is None else main_task_path
+
+    def as_state_log(self) -> SessionStateLog:
+        task_status_log: dict[str, TaskStatusStateLog] = {}
+        log_start_time = ""
+        for task, task_status in self._task_status.items():
+            history_log = [
+                TaskStatusHistoryStateLog(
+                    status=status,
+                    time=status_at.strftime("%Y-%m-%d %H:%M:%S.%f"),
+                )
+                for status, status_at in task_status.history
+            ]
+            if len(history_log) > 0 and (
+                log_start_time == "" or history_log[0].time < log_start_time
+            ):
+                log_start_time = history_log[0].time
+            task_status_log[task.name] = TaskStatusStateLog(
+                is_started=task_status.is_started,
+                is_ready=task_status.is_ready,
+                is_completed=task_status.is_completed,
+                is_skipped=task_status.is_skipped,
+                is_failed=task_status.is_failed,
+                is_permanently_failed=task_status.is_permanently_failed,
+                is_terminated=task_status.is_terminated,
+                history=history_log,
+            )
+        return SessionStateLog(
+            name=self.name,
+            start_time=log_start_time,
+            main_task_name=self._main_task.name,
+            path=self.task_path,
+            final_result=(
+                f"{self.final_result}" if self.final_result is not None else ""
+            ),
+            finished=self.is_terminated,
+            log=self.shared_ctx.shared_log,
+            input=self.shared_ctx.input,
+            task_status=task_status_log,
+        )
+
+    def get_ctx(self, task: AnyTask) -> AnyContext:
+        self._register_single_task(task)
+        return self._context[task]
+
+    def defer_monitoring(self, task: AnyTask, coro: Coroutine):
+        self._register_single_task(task)
+        self._monitoring_coros[task] = coro
+
+    def defer_action(self, task: AnyTask, coro: Coroutine):
+        self._register_single_task(task)
+        self._action_coros[task] = coro
+
+    def defer_coro(self, coro: Coroutine):
+        self._coros.append(coro)
+        self._coros = [
+            existing_coro for existing_coro in self._coros if not existing_coro.done()
+        ]
+
+    async def wait_deferred(self):
+        await self._wait_deferred_monitoring()
+        await self._wait_deferred_action()
+        await asyncio.gather(*self._coros)
+
+    async def _wait_deferred_action(self):
+        if len(self._action_coros) == 0:
+            return
+        task_coros = self._action_coros.values()
+        await asyncio.gather(*task_coros)
+
+    async def _wait_deferred_monitoring(self):
+        if len(self._monitoring_coros) == 0:
+            return
+        task_coros = self._monitoring_coros.values()
+        await asyncio.gather(*task_coros)
+
+    def register_task(self, task: AnyTask):
+        self._register_single_task(task)
+        for readiness_check in task.readiness_checks:
+            self.register_task(readiness_check)
+        for upstream in task.upstreams:
+            self.register_task(upstream)
+            if task not in self._downstreams[upstream]:
+                self._downstreams[upstream].append(task)
+            if upstream not in self._upstreams[task]:
+                self._upstreams[task].append(upstream)
+
+    def get_root_tasks(self, task: AnyTask) -> list[AnyTask]:
+        root_tasks = []
+        upstreams = self._upstreams[task]
+        if len(upstreams) == 0:
+            root_tasks.append(task)
+        else:
+            for upstream in upstreams:
+                root_tasks += self.get_root_tasks(upstream)
+        return list(set(root_tasks))
+
+    def get_next_tasks(self, task: AnyTask) -> list[AnyTask]:
+        self._register_single_task(task)
+        return self._downstreams.get(task)
+
+    def get_task_status(self, task: AnyTask) -> TaskStatus:
+        self._register_single_task(task)
+        return self._task_status[task]
+
+    def _register_single_task(self, task: AnyTask):
+        if task.name not in self._shared_ctx._xcom:
+            self._shared_ctx._xcom[task.name] = Xcom([])
+        if task not in self._context:
+            self._context[task] = Context(
+                shared_ctx=self._shared_ctx,
+                task_name=task.name,
+                color=self._get_color(task),
+                icon=self._get_icon(task),
+            )
+        if task not in self._task_status:
+            self._task_status[task] = TaskStatus()
+        if task not in self._downstreams:
+            self._downstreams[task] = []
+        if task not in self._upstreams:
+            self._upstreams[task] = []
+
+    def _get_color(self, task: AnyTask) -> int:
+        if task.color is not None:
+            return task.color
+        chosen = self._colors[self._color_index]
+        self._color_index += 1
+        if self._color_index >= len(self._colors):
+            self._color_index = 0
+        return chosen
+
+    def _get_icon(self, task: AnyTask) -> int:
+        if task.icon is not None:
+            return task.icon
+        chosen = self._icons[self._icon_index]
+        self._icon_index += 1
+        if self._icon_index >= len(self._icons):
+            self._icon_index = 0
+        return chosen
+
+    def is_allowed_to_run(self, task: AnyTask):
+        if self.is_terminated:
+            return False
+        self._register_single_task(task)
+        task_status = self.get_task_status(task)
+        if task_status.is_started or task_status.is_completed:
+            return False
+        unfulfilled_upstreams = [
+            upstream
+            for upstream in self._upstreams[task]
+            if not self._task_status[upstream].allow_run_downstream
+        ]
+        return len(unfulfilled_upstreams) == 0