pyrelay-workflow 0.1.0__py3-none-any.whl

pyrelay/__init__.py

@@ -0,0 +1,14 @@
+from .core import task, workflow, WorkflowRun
+from .exceptions import WorkflowError, TaskFailedError, TaskTimeoutError
+# Import visualizer to trigger WorkflowRun monkeypatching
+from . import visualizer
+
+__all__ = [
+    "task",
+    "workflow",
+    "WorkflowRun",
+    "WorkflowError",
+    "TaskFailedError",
+    "TaskTimeoutError",
+]
+

pyrelay/core.py

@@ -0,0 +1,220 @@
+import asyncio
+import contextvars
+from datetime import datetime
+from enum import Enum
+from typing import Any, Callable, Dict, Optional, Set
+import uuid
+
+# Async context storage for active workflow run
+active_run_context: contextvars.ContextVar[Optional["WorkflowRun"]] = contextvars.ContextVar(
+    "active_run_context", default=None
+)
+
+
+class TaskStatus(str, Enum):
+    PENDING = "PENDING"
+    running = "RUNNING"  # Case-insensitive compatibility
+    RUNNING = "RUNNING"
+    SUCCESS = "SUCCESS"
+    FAILED = "FAILED"
+    SKIPPED = "SKIPPED"
+
+
+class Task:
+    """Decorator wrapper that stores task metadata and intercepts calls inside workflows."""
+
+    def __init__(
+        self,
+        func: Callable[..., Any],
+        name: Optional[str] = None,
+        retries: int = 0,
+        retry_delay: float = 1.0,
+        backoff_factor: float = 2.0,
+        timeout: Optional[float] = None,
+    ):
+        self.func = func
+        self.name = name or func.__name__
+        self.retries = retries
+        self.retry_delay = retry_delay
+        self.backoff_factor = backoff_factor
+        self.timeout = timeout
+        self.is_coroutine = asyncio.iscoroutinefunction(func)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        run = active_run_context.get()
+        if not run:
+            # Standalone invocation (useful for unit testing)
+            return self.func(*args, **kwargs)
+
+        return run.execute_task(self, args, kwargs)
+
+
+class TaskInstance:
+    """Tracks state and telemetry for a single task execution."""
+
+    def __init__(self, task: Task, run_id: str):
+        self.id = str(uuid.uuid4())
+        self.task = task
+        self.name = task.name
+        self.run_id = run_id
+        self.status = TaskStatus.PENDING
+        
+        self.start_time: Optional[datetime] = None
+        self.end_time: Optional[datetime] = None
+        self.duration: float = 0.0
+        
+        self.attempts = 0
+        self.inputs: Dict[str, Any] = {}
+        self.result: Any = None
+        self.error: Optional[str] = None
+        self.predecessors: Set[str] = set()
+
+    def start(self, inputs: Dict[str, Any]) -> None:
+        self.status = TaskStatus.RUNNING
+        self.start_time = datetime.now()
+        self.inputs = inputs
+        self.attempts += 1
+
+    def complete(self, result: Any) -> None:
+        self.status = TaskStatus.SUCCESS
+        self.end_time = datetime.now()
+        if self.start_time:
+            self.duration = (self.end_time - self.start_time).total_seconds()
+        self.result = result
+
+    def fail(self, error: Exception) -> None:
+        self.status = TaskStatus.FAILED
+        self.end_time = datetime.now()
+        if self.start_time:
+            self.duration = (self.end_time - self.start_time).total_seconds()
+        self.error = f"{type(error).__name__}: {str(error)}"
+
+    def skip(self) -> None:
+        self.status = TaskStatus.SKIPPED
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "status": self.status.value,
+            "start_time": self.start_time.isoformat() if self.start_time else None,
+            "end_time": self.end_time.isoformat() if self.end_time else None,
+            "duration": self.duration,
+            "attempts": self.attempts,
+            "inputs": str(self.inputs),
+            "result": str(self.result) if self.result is not None else None,
+            "error": self.error,
+            "predecessors": list(self.predecessors),
+        }
+
+
+class Workflow:
+    """Blueprint representing a workflow defined with `@workflow`."""
+
+    def __init__(self, func: Callable[..., Any], name: Optional[str] = None):
+        self.func = func
+        self.name = name or func.__name__
+
+    def run(self, *args: Any, **kwargs: Any) -> "WorkflowRun":
+        run = WorkflowRun(self)
+        return run.run_sync(*args, **kwargs)
+
+    async def run_async(self, *args: Any, **kwargs: Any) -> "WorkflowRun":
+        run = WorkflowRun(self)
+        await run.run_async(*args, **kwargs)
+        return run
+
+
+class WorkflowRun:
+    """Coordinates the execution trace and lifecycle events for a single pipeline run."""
+
+    def __init__(self, workflow: Workflow):
+        self.id = str(uuid.uuid4())
+        self.workflow = workflow
+        self.status = "PENDING"
+        self.start_time: Optional[datetime] = None
+        self.end_time: Optional[datetime] = None
+        self.duration: float = 0.0
+        self.result: Any = None
+        self.error: Optional[str] = None
+
+        self.tasks: Dict[str, TaskInstance] = {}
+        self.event_callbacks: List[Callable[[str, Any], None]] = []
+        self.executor_hook: Optional[Callable[[Task, tuple, dict], Any]] = None
+
+    def add_event_callback(self, callback: Callable[[str, Any], None]) -> None:
+        self.event_callbacks.append(callback)
+
+    def emit_event(self, event_type: str, data: Any) -> None:
+        for cb in self.event_callbacks:
+            try:
+                cb(event_type, data)
+            except Exception:
+                pass
+
+    def get_frontier(self) -> Set[str]:
+        """Identifies completed tasks that have no dependent downstream runs.
+        
+        Uses:
+        Frontier = {Completed} - {Predecessors of any task}
+        """
+        all_completed = {
+            t_id for t_id, t in self.tasks.items() 
+            if t.status in (TaskStatus.SUCCESS, TaskStatus.FAILED, TaskStatus.SKIPPED)
+        }
+        
+        all_predecessors = set()
+        for t in self.tasks.values():
+            all_predecessors.update(t.predecessors)
+            
+        return all_completed - all_predecessors
+
+    def execute_task(self, task: Task, args: tuple, kwargs: dict) -> Any:
+        if not self.executor_hook:
+            raise RuntimeError("Engine runner not initialized on this WorkflowRun.")
+        return self.executor_hook(task, args, kwargs)
+
+    def run_sync(self, *args: Any, **kwargs: Any) -> "WorkflowRun":
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        if loop.is_running():
+            # Jupyter and FastAPI loops are already running; patch to prevent loop collision
+            import nest_asyncio
+            nest_asyncio.apply()
+            
+        loop.run_until_complete(self.run_async(*args, **kwargs))
+        return self
+
+    async def run_async(self, *args: Any, **kwargs: Any) -> None:
+        from .engine import ExecutionEngine
+        engine = ExecutionEngine(self)
+        await engine.run(args, kwargs)
+
+
+def task(
+    name: Optional[str] = None,
+    retries: int = 0,
+    retry_delay: float = 1.0,
+    backoff_factor: float = 2.0,
+    timeout: Optional[float] = None,
+) -> Callable[[Callable[..., Any]], Task]:
+    def decorator(func: Callable[..., Any]) -> Task:
+        return Task(
+            func=func,
+            name=name,
+            retries=retries,
+            retry_delay=retry_delay,
+            backoff_factor=backoff_factor,
+            timeout=timeout,
+        )
+    return decorator
+
+
+def workflow(name: Optional[str] = None) -> Callable[[Callable[..., Any]], Workflow]:
+    def decorator(func: Callable[..., Any]) -> Workflow:
+        return Workflow(func=func, name=name)
+    return decorator

pyrelay/dashboard.py

@@ -0,0 +1,231 @@
+from datetime import datetime
+import time
+from typing import Any, Dict, List
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, TextColumn
+from rich.table import Table
+from rich.text import Text
+from rich.layout import Layout
+from .core import TaskInstance, TaskStatus, WorkflowRun
+
+
+class ConsoleDashboard:
+    """Renders a live, real-time dashboard in the terminal for a WorkflowRun."""
+
+    def __init__(self, run: WorkflowRun):
+        self.run = run
+        self.console = Console()
+        self.logs: List[str] = []
+        self.live: Optional[Live] = None
+        self.start_time = time.time()
+        
+        # Register callbacks
+        self.run.add_event_callback(self.handle_event)
+
+    def log(self, message: str) -> None:
+        timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+        self.logs.append(f"[{timestamp}] {message}")
+        if len(self.logs) > 8:
+            self.logs.pop(0)
+
+    def handle_event(self, event_type: str, data: Any) -> None:
+        """Handles engine events and updates the internal state and logs."""
+        if event_type == "workflow_start":
+            self.log(f"🚀 Workflow '{data.workflow.name}' started (Run ID: {data.id[:8]})")
+            # Initialize Live view
+            self.live = Live(self.make_layout(), console=self.console, refresh_per_second=4, transient=False)
+            self.live.start()
+        
+        elif event_type == "workflow_success":
+            self.log(f"✅ Workflow '{data.workflow.name}' completed successfully!")
+            self._update_live()
+            if self.live:
+                self.live.stop()
+                self.live = None
+            self._print_final_summary()
+            
+        elif event_type == "workflow_failure":
+            self.log(f"❌ Workflow '{data.workflow.name}' failed: {data.error}")
+            self._update_live()
+            if self.live:
+                self.live.stop()
+                self.live = None
+            self._print_final_summary()
+
+        elif event_type == "task_pending":
+            self.log(f"⏳ Task '{data.name}' pending dependencies")
+            self._update_live()
+
+        elif event_type == "task_start":
+            self.log(f"🔄 Task '{data.name}' started (Attempt {data.attempts})")
+            self._update_live()
+
+        elif event_type == "task_success":
+            self.log(f"✅ Task '{data.name}' finished in {data.duration:.2f}s")
+            self._update_live()
+
+        elif event_type == "task_retry":
+            self.log(f"⚠️ Task '{data.name}' failed, retrying (Attempt {data.attempts})...")
+            self._update_live()
+
+        elif event_type == "task_timeout":
+            self.log(f"⏱️ Task '{data.name}' timed out!")
+            self._update_live()
+
+        elif event_type == "task_fail":
+            self.log(f"❌ Task '{data.name}' failed: {data.error}")
+            self._update_live()
+
+        elif event_type == "task_skip":
+            self.log(f"⏭️ Task '{data.name}' skipped due to upstream failure")
+            self._update_live()
+
+    def _update_live(self) -> None:
+        if self.live:
+            self.live.update(self.make_layout())
+
+    def make_layout(self) -> Layout:
+        """Constructs the Rich layout split into Header, Body (Tasks), and Footer (Logs)."""
+        layout = Layout()
+        layout.split_column(
+            Layout(name="header", size=4),
+            Layout(name="body", ratio=1),
+            Layout(name="footer", size=10),
+        )
+
+        # Header panel
+        duration = time.time() - self.start_time
+        status_colors = {
+            "PENDING": "grey50",
+            "RUNNING": "bold blue",
+            "SUCCESS": "bold green",
+            "FAILED": "bold red",
+        }
+        status_color = status_colors.get(self.run.status, "white")
+        
+        header_text = Text.assemble(
+            ("⚡ PYRELAY WORKFLOW RUNNER  ", "bold magenta"),
+            (f"|  Workflow: ", "dim"),
+            (f"{self.run.workflow.name}  ", "bold white"),
+            (f"|  Status: ", "dim"),
+            (f"{self.run.status}  ", status_color),
+            (f"|  Elapsed: ", "dim"),
+            (f"{duration:.2f}s", "bold yellow"),
+        )
+        layout["header"].update(Panel(header_text, border_style="magenta"))
+
+        # Body - Tasks Table
+        table = Table(expand=True, border_style="dim")
+        table.add_column("Task ID", style="dim", width=10)
+        table.add_column("Task Name", style="bold white")
+        table.add_column("Status", width=12)
+        table.add_column("Duration", justify="right", width=10)
+        table.add_column("Attempts", justify="right", width=8)
+        table.add_column("Predecessors", style="dim")
+        table.add_column("Result / Error", ratio=1)
+
+        status_styles = {
+            TaskStatus.PENDING: "[grey50]PENDING[/]",
+            TaskStatus.RUNNING: "[bold blue]RUNNING[/]",
+            TaskStatus.SUCCESS: "[bold green]SUCCESS[/]",
+            TaskStatus.FAILED: "[bold red]FAILED[/]",
+            TaskStatus.SKIPPED: "[bold yellow]SKIPPED[/]",
+        }
+
+        for task_id, t in self.run.tasks.items():
+            duration_str = f"{t.duration:.2f}s" if t.duration > 0 else "-"
+            status_str = status_styles.get(t.status, str(t.status))
+            
+            # Show output or error summary
+            out_str = ""
+            if t.status == TaskStatus.SUCCESS:
+                out_str = f"[green]{str(t.result)[:50]}[/]"
+                if len(str(t.result)) > 50:
+                    out_str += "..."
+            elif t.status == TaskStatus.FAILED:
+                out_str = f"[red]{t.error}[/]"
+            elif t.status == TaskStatus.SKIPPED:
+                out_str = "[yellow]Dependency failed[/]"
+
+            # Map predecessor names
+            preds = []
+            for p_id in t.predecessors:
+                if p_id in self.run.tasks:
+                    preds.append(self.run.tasks[p_id].name)
+            preds_str = ", ".join(preds) if preds else "-"
+
+            table.add_row(
+                t.id[:8],
+                t.name,
+                status_str,
+                duration_str,
+                str(t.attempts),
+                preds_str,
+                out_str,
+            )
+
+        layout["body"].update(Panel(table, title="[bold cyan]Execution Graph Nodes[/]", border_style="cyan"))
+
+        # Footer - Live Logs
+        logs_text = Text()
+        for log_line in self.logs:
+            if "✅" in log_line or "success" in log_line.lower():
+                logs_text.append(log_line + "\n", style="green")
+            elif "❌" in log_line or "fail" in log_line.lower():
+                logs_text.append(log_line + "\n", style="red")
+            elif "⚠️" in log_line or "retry" in log_line.lower():
+                logs_text.append(log_line + "\n", style="yellow")
+            elif "🚀" in log_line:
+                logs_text.append(log_line + "\n", style="bold white")
+            else:
+                logs_text.append(log_line + "\n", style="dim white")
+
+        layout["footer"].update(Panel(logs_text, title="[bold white]Real-Time Log Stream[/]", border_style="dim"))
+        return layout
+
+    def _print_final_summary(self) -> None:
+        """Prints a clean, polished console summary table after execution completes."""
+        self.console.print("\n")
+        self.console.print(Panel(
+            Text.assemble(
+                ("🏁 Workflow execution finished. ", "bold green" if self.run.status == "SUCCESS" else "bold red"),
+                (f"Total time: {self.run.duration:.2f}s", "yellow")
+            ),
+            border_style="green" if self.run.status == "SUCCESS" else "red"
+        ))
+        
+        table = Table(title="Execution Summary", show_header=True, header_style="bold magenta")
+        table.add_column("Task Name", style="bold white")
+        table.add_column("Status")
+        table.add_column("Duration")
+        table.add_column("Result / Error Summary", ratio=1)
+
+        status_colors = {
+            TaskStatus.SUCCESS: "green",
+            TaskStatus.FAILED: "red",
+            TaskStatus.SKIPPED: "yellow",
+        }
+
+        for t in self.run.tasks.values():
+            color = status_colors.get(t.status, "white")
+            status_text = Text(t.status.value, style=f"bold {color}")
+            
+            result_summary = ""
+            if t.status == TaskStatus.SUCCESS:
+                result_summary = str(t.result)[:100]
+                if len(str(t.result)) > 100:
+                    result_summary += "..."
+            elif t.status == TaskStatus.FAILED:
+                result_summary = t.error or "Unknown error"
+
+            table.add_row(
+                t.name,
+                status_text,
+                f"{t.duration:.2f}s" if t.duration > 0 else "-",
+                result_summary
+            )
+
+        self.console.print(table)
+        self.console.print("\n")

pyrelay/engine.py

@@ -0,0 +1,191 @@
+import asyncio
+from datetime import datetime
+import inspect
+import time
+from typing import Any, Callable, Dict, Tuple
+from .core import Task, TaskInstance, TaskStatus, WorkflowRun, active_run_context
+from .exceptions import TaskFailedError, TaskTimeoutError
+
+
+class ExecutionEngine:
+    """Manages scheduling, timeouts, and state-machine transitions for task runs."""
+
+    def __init__(self, run: WorkflowRun):
+        self.workflow_run = run
+        self.workflow_run.executor_hook = self.execute_task
+
+    async def run(self, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> None:
+        self.workflow_run.status = "RUNNING"
+        self.workflow_run.start_time = datetime.now()
+        self.workflow_run.emit_event("workflow_start", self.workflow_run)
+
+        token = active_run_context.set(self.workflow_run)
+        try:
+            if asyncio.iscoroutinefunction(self.workflow_run.workflow.func):
+                result = await self.workflow_run.workflow.func(*args, **kwargs)
+            else:
+                result = self.workflow_run.workflow.func(*args, **kwargs)
+                
+            self.workflow_run.status = "SUCCESS"
+            self.workflow_run.result = result
+            self.workflow_run.emit_event("workflow_success", self.workflow_run)
+        except Exception as e:
+            self.workflow_run.status = "FAILED"
+            self.workflow_run.error = f"{type(e).__name__}: {str(e)}"
+            self.workflow_run.emit_event("workflow_failure", self.workflow_run)
+            raise e
+        finally:
+            self.workflow_run.end_time = datetime.now()
+            if self.workflow_run.start_time:
+                self.workflow_run.duration = (self.workflow_run.end_time - self.workflow_run.start_time).total_seconds()
+            active_run_context.reset(token)
+            self.workflow_run.emit_event("workflow_end", self.workflow_run)
+
+    def execute_task(self, task: Task, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Any:
+        is_workflow_async = asyncio.iscoroutinefunction(self.workflow_run.workflow.func)
+        if is_workflow_async:
+            return self._async_task_wrapper(task, args, kwargs)
+        return self._sync_task_wrapper(task, args, kwargs)
+
+    async def _async_task_wrapper(self, task: Task, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Any:
+        task_instance = TaskInstance(task, self.workflow_run.id)
+        task_instance.predecessors = self.workflow_run.get_frontier()
+        self.workflow_run.tasks[task_instance.id] = task_instance
+        self.workflow_run.emit_event("task_pending", task_instance)
+
+        inputs = self._bind_arguments(task.func, args, kwargs)
+        task_instance.start(inputs)
+        self.workflow_run.emit_event("task_start", task_instance)
+
+        delay = task.retry_delay
+        last_exception = None
+
+        for attempt in range(max(1, task.retries + 1)):
+            if attempt > 0:
+                task_instance.attempts += 1
+                task_instance.status = TaskStatus.RUNNING
+                self.workflow_run.emit_event("task_retry", task_instance)
+                await asyncio.sleep(delay)
+                delay *= task.backoff_factor
+
+            try:
+                if task.is_coroutine:
+                    if task.timeout is not None:
+                        result = await asyncio.wait_for(
+                            task.func(*args, **kwargs), timeout=task.timeout
+                        )
+                    else:
+                        result = await task.func(*args, **kwargs)
+                else:
+                    # Offload sync functions to an executor thread to avoid blocking the event loop
+                    loop = asyncio.get_running_loop()
+                    if task.timeout is not None:
+                        result = await asyncio.wait_for(
+                            loop.run_in_executor(None, lambda: task.func(*args, **kwargs)),
+                            timeout=task.timeout
+                        )
+                    else:
+                        result = await loop.run_in_executor(None, lambda: task.func(*args, **kwargs))
+
+                task_instance.complete(result)
+                self.workflow_run.emit_event("task_success", task_instance)
+                return result
+
+            except asyncio.TimeoutError:
+                last_exception = TaskTimeoutError(task.name, task.timeout or 0)
+                task_instance.fail(last_exception)
+                self.workflow_run.emit_event("task_timeout", task_instance)
+            except Exception as e:
+                last_exception = e
+                task_instance.fail(e)
+                self.workflow_run.emit_event("task_fail", task_instance)
+
+        final_err = TaskFailedError(task.name, last_exception or Exception("Unknown error"))
+        self._cascade_skipped_tasks(task_instance.id)
+        raise final_err
+
+    def _sync_task_wrapper(self, task: Task, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Any:
+        task_instance = TaskInstance(task, self.workflow_run.id)
+        task_instance.predecessors = self.workflow_run.get_frontier()
+        self.workflow_run.tasks[task_instance.id] = task_instance
+        self.workflow_run.emit_event("task_pending", task_instance)
+
+        inputs = self._bind_arguments(task.func, args, kwargs)
+        task_instance.start(inputs)
+        self.workflow_run.emit_event("task_start", task_instance)
+
+        delay = task.retry_delay
+        last_exception = None
+
+        for attempt in range(max(1, task.retries + 1)):
+            if attempt > 0:
+                task_instance.attempts += 1
+                task_instance.status = TaskStatus.RUNNING
+                self.workflow_run.emit_event("task_retry", task_instance)
+                time.sleep(delay)
+                delay *= task.backoff_factor
+
+            try:
+                if task.timeout is not None:
+                    # Sync timeouts are checked by joining a helper execution thread
+                    import threading
+                    result_container = []
+                    error_container = []
+
+                    def target():
+                        try:
+                            res = task.func(*args, **kwargs)
+                            result_container.append(res)
+                        except Exception as ex:
+                            error_container.append(ex)
+
+                    t = threading.Thread(target=target)
+                    t.start()
+                    t.join(timeout=task.timeout)
+
+                    if t.is_alive():
+                        raise TaskTimeoutError(task.name, task.timeout)
+                    if error_container:
+                        raise error_container[0]
+                    result = result_container[0]
+                else:
+                    result = task.func(*args, **kwargs)
+
+                task_instance.complete(result)
+                self.workflow_run.emit_event("task_success", task_instance)
+                return result
+
+            except TaskTimeoutError as te:
+                last_exception = te
+                task_instance.fail(te)
+                self.workflow_run.emit_event("task_timeout", task_instance)
+            except Exception as e:
+                last_exception = e
+                task_instance.fail(e)
+                self.workflow_run.emit_event("task_fail", task_instance)
+
+        final_err = TaskFailedError(task.name, last_exception or Exception("Unknown error"))
+        self._cascade_skipped_tasks(task_instance.id)
+        raise final_err
+
+    def _cascade_skipped_tasks(self, failed_task_id: str) -> None:
+        for t_id, t in self.tasks_to_cascade(failed_task_id):
+            t.skip()
+            self.workflow_run.emit_event("task_skip", t)
+
+    def tasks_to_cascade(self, parent_id: str) -> list:
+        children = []
+        for t_id, t in self.workflow_run.tasks.items():
+            if parent_id in t.predecessors and t.status == TaskStatus.PENDING:
+                children.append((t_id, t))
+                children.extend(self.tasks_to_cascade(t_id))
+        return children
+
+    def _bind_arguments(self, func: Callable, args: tuple, kwargs: dict) -> Dict[str, Any]:
+        try:
+            sig = inspect.signature(func)
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+            return {k: str(v) for k, v in bound.arguments.items()}
+        except Exception:
+            return {"args": str(args), "kwargs": str(kwargs)}

pyrelay/exceptions.py

@@ -0,0 +1,19 @@
+class WorkflowError(Exception):
+    """Base exception for all pyrelay errors."""
+    pass
+
+
+class TaskFailedError(WorkflowError):
+    """Raised when a task fails and all retries are exhausted."""
+    def __init__(self, task_name: str, exception: Exception):
+        super().__init__(f"Task '{task_name}' failed: {exception}")
+        self.task_name = task_name
+        self.original_exception = exception
+
+
+class TaskTimeoutError(WorkflowError):
+    """Raised when a task execution times out."""
+    def __init__(self, task_name: str, timeout: float):
+        super().__init__(f"Task '{task_name}' timed out after {timeout}s")
+        self.task_name = task_name
+        self.timeout = timeout

pyrelay/visualizer.py

@@ -0,0 +1,461 @@
+import json
+import os
+from typing import Any, Dict
+from .core import WorkflowRun, TaskStatus
+
+
+class HTMLVisualizer:
+    """Generates an interactive web graph for a WorkflowRun using Vis-Network."""
+
+    def __init__(self, run: WorkflowRun):
+        self.run = run
+
+    def generate_html(self) -> str:
+        nodes_data = []
+        edges_data = []
+
+        status_colors = {
+            TaskStatus.PENDING.value: {"background": "#374151", "border": "#4b5563", "color": "#9ca3af"},
+            TaskStatus.RUNNING.value: {"background": "#1e40af", "border": "#3b82f6", "color": "#eff6ff"},
+            TaskStatus.SUCCESS.value: {"background": "#064e3b", "border": "#10b981", "color": "#ecfdf5"},
+            TaskStatus.FAILED.value: {"background": "#7f1d1d", "border": "#ef4444", "color": "#fef2f2"},
+            TaskStatus.SKIPPED.value: {"background": "#78350f", "border": "#f59e0b", "color": "#fffbeb"},
+        }
+
+        for t_id, t in self.run.tasks.items():
+            colors = status_colors.get(t.status.value, {"background": "#1f2937", "border": "#374151", "color": "#ffffff"})
+            
+            node_label = f"<b>{t.name}</b>\n<i>{t.status.value}</i>"
+            if t.duration > 0:
+                node_label += f"\n{t.duration:.2f}s"
+
+            inspect_payload = {
+                "id": t.id,
+                "name": t.name,
+                "status": t.status.value,
+                "duration": f"{t.duration:.3f}s" if t.duration > 0 else "-",
+                "attempts": t.attempts,
+                "start_time": t.start_time.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] if t.start_time else "-",
+                "end_time": t.end_time.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] if t.end_time else "-",
+                "inputs": t.inputs,
+                "result": str(t.result) if t.result is not None else None,
+                "error": t.error,
+            }
+
+            nodes_data.append({
+                "id": t.id,
+                "label": node_label,
+                "title": f"Task: {t.name} ({t.status.value})",
+                "shape": "box",
+                "margin": 12,
+                "font": {"multi": "html", "color": colors["color"], "size": 14},
+                "color": {
+                    "background": colors["background"],
+                    "border": colors["border"],
+                    "highlight": {"background": colors["border"], "border": "#ffffff"}
+                },
+                "borderWidth": 2,
+                "shadow": True,
+                "inspect": inspect_payload
+            })
+
+            for pred_id in t.predecessors:
+                edge_color = "#4b5563"
+                if pred_id in self.run.tasks:
+                    pred_task = self.run.tasks[pred_id]
+                    if pred_task.status == TaskStatus.SUCCESS:
+                        edge_color = "#10b981"
+                    elif pred_task.status == TaskStatus.FAILED:
+                        edge_color = "#ef4444"
+
+                edges_data.append({
+                    "from": pred_id,
+                    "to": t.id,
+                    "arrows": "to",
+                    "color": {"color": edge_color, "highlight": "#ffffff", "inherit": False},
+                    "width": 2,
+                    "smooth": {"type": "cubicBezier", "forceDirection": "horizontal", "roundness": 0.5}
+                })
+
+        nodes_json = json.dumps(nodes_data, indent=2)
+        edges_json = json.dumps(edges_data, indent=2)
+
+        html_template = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>pyrelay DAG Visualizer - {self.run.workflow.name}</title>
+    
+    <!-- Vis Network CSS & JS CDN -->
+    <script type="text/javascript" src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+    
+    <!-- Google Fonts Outfit -->
+    <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;600;700&display=swap" rel="stylesheet">
+    
+    <style>
+        * {{
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }}
+        body {{
+            font-family: 'Outfit', sans-serif;
+            background-color: #0d0e12;
+            color: #e4e4e7;
+            height: 100vh;
+            overflow: hidden;
+            display: flex;
+        }}
+        #container {{
+            flex: 1;
+            height: 100%;
+            position: relative;
+        }}
+        #network {{
+            width: 100%;
+            height: 100%;
+        }}
+        #header {{
+            position: absolute;
+            top: 20px;
+            left: 20px;
+            z-index: 10;
+            background: rgba(20, 21, 28, 0.85);
+            backdrop-filter: blur(12px);
+            border: 1px solid rgba(255, 255, 255, 0.08);
+            padding: 16px 24px;
+            border-radius: 12px;
+            box-shadow: 0 8px 32px 0 rgba(0, 0, 0, 0.37);
+            max-width: 400px;
+        }}
+        #header h1 {{
+            font-size: 1.25rem;
+            font-weight: 700;
+            color: #ff007f;
+            margin-bottom: 4px;
+            letter-spacing: 0.5px;
+        }}
+        #header h2 {{
+            font-size: 1rem;
+            font-weight: 600;
+            color: #ffffff;
+            margin-bottom: 8px;
+        }}
+        .meta-item {{
+            font-size: 0.85rem;
+            margin-bottom: 4px;
+            color: #a1a1aa;
+        }}
+        .meta-value {{
+            font-weight: 600;
+            color: #f4f4f5;
+        }}
+        .status-badge {{
+            display: inline-block;
+            padding: 2px 8px;
+            border-radius: 4px;
+            font-size: 0.75rem;
+            font-weight: 700;
+            text-transform: uppercase;
+        }}
+        .status-SUCCESS {{ background: #064e3b; color: #34d399; border: 1px solid #059669; }}
+        .status-FAILED {{ background: #7f1d1d; color: #f87171; border: 1px solid #dc2626; }}
+        .status-RUNNING {{ background: #1e40af; color: #60a5fa; border: 1px solid #2563eb; }}
+        
+        #sidebar {{
+            width: 400px;
+            background-color: #14151c;
+            border-left: 1px solid rgba(255, 255, 255, 0.08);
+            box-shadow: -8px 0 32px 0 rgba(0, 0, 0, 0.37);
+            display: flex;
+            flex-column: column;
+            flex-direction: column;
+            transform: translateX(100%);
+            transition: transform 0.3s cubic-bezier(0.16, 1, 0.3, 1);
+            position: absolute;
+            right: 0;
+            top: 0;
+            height: 100%;
+            z-index: 100;
+        }}
+        #sidebar.open {{
+            transform: translateX(0);
+        }}
+        #sidebar-header {{
+            padding: 24px;
+            border-bottom: 1px solid rgba(255, 255, 255, 0.08);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }}
+        #sidebar-title {{
+            font-size: 1.25rem;
+            font-weight: 700;
+            color: #ffffff;
+        }}
+        #close-btn {{
+            background: none;
+            border: none;
+            color: #a1a1aa;
+            font-size: 1.5rem;
+            cursor: pointer;
+            padding: 4px;
+            line-height: 1;
+        }}
+        #close-btn:hover {{
+            color: #ffffff;
+        }}
+        #sidebar-content {{
+            padding: 24px;
+            flex: 1;
+            overflow-y: auto;
+        }}
+        .section-title {{
+            font-size: 0.8rem;
+            font-weight: 700;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+            color: #71717a;
+            margin-top: 20px;
+            margin-bottom: 8px;
+        }}
+        .detail-card {{
+            background: rgba(255, 255, 255, 0.03);
+            border: 1px solid rgba(255, 255, 255, 0.05);
+            border-radius: 8px;
+            padding: 12px;
+            margin-bottom: 16px;
+        }}
+        .pre-container {{
+            background: #090a0f;
+            border: 1px solid rgba(255, 255, 255, 0.04);
+            border-radius: 6px;
+            padding: 12px;
+            font-family: monospace;
+            font-size: 0.85rem;
+            overflow-x: auto;
+            color: #a5f3fc;
+            max-height: 250px;
+        }}
+        .error-panel {{
+            background: rgba(239, 68, 68, 0.1);
+            border: 1px solid rgba(239, 68, 68, 0.2);
+            color: #fca5a5;
+            border-radius: 8px;
+            padding: 12px;
+            font-family: monospace;
+            font-size: 0.85rem;
+            margin-top: 10px;
+        }}
+        #empty-state {{
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            color: #71717a;
+            font-size: 0.95rem;
+            text-align: center;
+            padding: 40px;
+        }}
+        .instruction-banner {{
+            position: absolute;
+            bottom: 20px;
+            left: 20px;
+            background: rgba(20, 21, 28, 0.7);
+            padding: 8px 16px;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            color: #a1a1aa;
+            border: 1px solid rgba(255, 255, 255, 0.05);
+            z-index: 10;
+        }}
+    </style>
+</head>
+<body>
+    <div id="container">
+        <div id="header">
+            <h1>⚡ PYRELAY</h1>
+            <h2>{self.run.workflow.name}</h2>
+            <div class="meta-item">Status: <span class="status-badge status-{self.run.status}">{self.run.status}</span></div>
+            <div class="meta-item">Run ID: <span class="meta-value">{self.run.id[:8]}...</span></div>
+            <div class="meta-item">Total Duration: <span class="meta-value">{self.run.duration:.3f}s</span></div>
+            <div class="meta-item">Tasks Traced: <span class="meta-value">{len(self.run.tasks)}</span></div>
+        </div>
+        
+        <div class="instruction-banner">
+            💡 Click on any task node to inspect inputs, outputs, error traces, and run times.
+        </div>
+
+        <div id="network"></div>
+    </div>
+
+    <div id="sidebar">
+        <div id="sidebar-header">
+            <span id="sidebar-title">Task Details</span>
+            <button id="close-btn" onclick="closeSidebar()">&times;</button>
+        </div>
+        <div id="sidebar-content">
+            <div id="empty-state">
+                Select a task node to view execution telemetry.
+            </div>
+            <div id="details-view" style="display: none;">
+                <div class="meta-item" style="font-size: 1.1rem; color: #fff; margin-bottom: 12px;">
+                    Task Name: <span id="task-name" style="font-weight: bold; color: #ff007f;">-</span>
+                </div>
+                
+                <div class="detail-card">
+                    <div style="display: flex; justify-content: space-between; margin-bottom: 8px;">
+                        <span>Status:</span>
+                        <span id="task-status" class="status-badge">-</span>
+                    </div>
+                    <div style="display: flex; justify-content: space-between; margin-bottom: 8px;">
+                        <span>Duration:</span>
+                        <span id="task-duration" style="font-weight: 600; color: #fbbf24;">-</span>
+                    </div>
+                    <div style="display: flex; justify-content: space-between;">
+                        <span>Attempts:</span>
+                        <span id="task-attempts" style="font-weight: 600;">-</span>
+                    </div>
+                </div>
+
+                <div class="section-title">Timeline</div>
+                <div class="detail-card" style="font-size: 0.85rem; color: #a1a1aa;">
+                    <div style="margin-bottom: 6px;">Started: <span id="task-start" style="color: #f4f4f5; font-family: monospace;">-</span></div>
+                    <div>Finished: <span id="task-end" style="color: #f4f4f5; font-family: monospace;">-</span></div>
+                </div>
+
+                <div class="section-title">Inputs</div>
+                <pre id="task-inputs" class="pre-container">-</pre>
+
+                <div class="section-title">Output / Result</div>
+                <pre id="task-result" class="pre-container">-</pre>
+
+                <div id="error-section" style="display: none;">
+                    <div class="section-title" style="color: #ef4444;">Exception Trace</div>
+                    <div id="task-error" class="error-panel">-</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script type="text/javascript">
+        const nodesData = {nodes_json};
+        const edgesData = {edges_json};
+
+        const nodes = new vis.DataSet(nodesData);
+        const edges = new vis.DataSet(edgesData);
+
+        const container = document.getElementById('network');
+        const data = {{ nodes: nodes, edges: edges }};
+
+        const options = {{
+            nodes: {{
+                shape: 'box',
+                font: {{
+                    face: 'Outfit',
+                }}
+            }},
+            edges: {{
+                font: {{
+                    face: 'Outfit'
+                }}
+            }},
+            layout: {{
+                hierarchical: {{
+                    enabled: true,
+                    direction: 'LR',
+                    sortMethod: 'directed',
+                    nodeSpacing: 180,
+                    levelSeparation: 250,
+                    parentCentralization: true
+                }}
+            }},
+            physics: {{
+                hierarchicalRepulsion: {{
+                    nodeDistance: 200
+                }}
+            }},
+            interaction: {{
+                hover: true,
+                tooltipDelay: 200
+            }}
+        }};
+
+        const network = new vis.Network(container, data, options);
+        
+        const sidebar = document.getElementById('sidebar');
+        const emptyState = document.getElementById('empty-state');
+        const detailsView = document.getElementById('details-view');
+
+        network.on("click", function(params) {{
+            if (params.nodes.length > 0) {{
+                const nodeId = params.nodes[0];
+                const node = nodes.get(nodeId);
+                
+                if (node && node.inspect) {{
+                    showDetails(node.inspect);
+                }}
+            }} else {{
+                closeSidebar();
+            }}
+        }});
+
+        function showDetails(inspect) {{
+            emptyState.style.display = 'none';
+            detailsView.style.display = 'block';
+            sidebar.classList.add('open');
+
+            document.getElementById('task-name').textContent = inspect.name;
+            
+            const statusBadge = document.getElementById('task-status');
+            statusBadge.className = 'status-badge status-' + inspect.status;
+            statusBadge.textContent = inspect.status;
+            
+            document.getElementById('task-duration').textContent = inspect.duration;
+            document.getElementById('task-attempts').textContent = inspect.attempts;
+            document.getElementById('task-start').textContent = inspect.start_time;
+            document.getElementById('task-end').textContent = inspect.end_time;
+            
+            const inputsElem = document.getElementById('task-inputs');
+            try {{
+                inputsElem.textContent = JSON.stringify(inspect.inputs, null, 2);
+            }} catch(e) {{
+                inputsElem.textContent = String(inspect.inputs);
+            }}
+            
+            const resultElem = document.getElementById('task-result');
+            resultElem.textContent = inspect.result !== null ? inspect.result : 'None';
+            
+            const errorSection = document.getElementById('error-section');
+            if (inspect.error) {{
+                errorSection.style.display = 'block';
+                document.getElementById('task-error').textContent = inspect.error;
+            }} else {{
+                errorSection.style.display = 'none';
+            }}
+        }}
+
+        function closeSidebar() {{
+            sidebar.classList.remove('open');
+        }}
+    </script>
+</body>
+</html>
+"""
+        return html_template
+
+    def save(self, filepath: str) -> None:
+        directory = os.path.dirname(filepath)
+        if directory and not os.path.exists(directory):
+            os.makedirs(directory, exist_ok=True)
+            
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(self.generate_html())
+
+
+def visualize_run(self: WorkflowRun, filepath: str) -> None:
+    visualizer = HTMLVisualizer(self)
+    visualizer.save(filepath)
+
+WorkflowRun.visualize = visualize_run

pyrelay_workflow-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: pyrelay-workflow
+Version: 0.1.0
+Summary: A lightweight, async-first Python workflow engine with dynamic branching and rich visual dashboarding.
+Author-email: Developer <developer@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=12.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.18.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# ⚡ pyrelay
+
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.0-blue.svg)](https://pypi.org/project/pyrelay/)
+[![Python versions](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue.svg)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+`pyrelay` is a lightweight, high-performance, async-first Python workflow engine. It allows developers to model, execute, and monitor complex task pipelines with native pythonic flows (`if/else` branching), zero complex DSLs, live terminal dashboards, and interactive web visualizers.
+
+---
+
+## ✨ Features
+
+- **🐍 Native Python Branching**: Use standard Python `if/else` and loops. The execution graph is discovered dynamically at runtime.
+- **⚡ Async-First Architecture**: Built natively on top of Python `asyncio`. Executes independent tasks concurrently.
+- **🧵 Auto-Offloading for Sync Tasks**: Run blocking synchronous functions without stalling the async event loop (automatically offloaded to thread executors).
+- **⏱️ Fault Tolerance**: Custom task-level retry policies, exponential backoff, and timeouts out-of-the-box.
+- **🖥️ Live Console Dashboard**: Animated status trees, progress bars, and log streams in your terminal powered by `rich`.
+- **🌐 Draggable HTML/JS Visualizer**: Compile any workflow run into a standalone dark-mode HTML file containing a responsive network chart powered by Vis-Network.
+
+---
+
+## 📦 Installation
+
+Initialize your project and install `pyrelay`:
+
+```bash
+pip install pyrelay
+```
+
+*(Requires Python 3.9+)*
+
+---
+
+## 🚀 Quickstart
+
+Create a workflow by wrapping functions with `@task` and `@workflow`. Awaited tasks automatically map dependencies based on their execution order!
+
+```python
+import asyncio
+from pyrelay import task, workflow, WorkflowRun
+from pyrelay.dashboard import ConsoleDashboard
+
+@task(retries=2, retry_delay=0.5)
+async def fetch_user_data(user_id: int):
+    await asyncio.sleep(0.5)
+    return {"id": user_id, "name": "Alice", "status": "active"}
+
+@task()
+async def process_account(user: dict):
+    await asyncio.sleep(0.3)
+    return f"Account processed for {user['name']}"
+
+@workflow(name="Account Pipeline")
+async def account_flow(user_id: int):
+    user = await fetch_user_data(user_id)
+    result = await process_account(user)
+    return result
+
+if __name__ == "__main__":
+    run = WorkflowRun(account_flow)
+    
+    # Attach the live CLI dashboard
+    ConsoleDashboard(run)
+    
+    # Run the workflow blocking/sync
+    run.run_sync(user_id=101)
+```
+
+---
+
+## 🌿 Dynamic Branching (Option B)
+
+In `pyrelay`, branching is simply Python. The engine tracks exactly which path was taken and marks skipped branches appropriately in reports.
+
+```python
+@task()
+async def process_premium_user(user: dict):
+    return "VIP treatment applied"
+
+@task()
+async def process_standard_user(user: dict):
+    return "Standard access configured"
+
+@workflow(name="User Routing")
+async def user_routing_flow(user: dict):
+    # Branching happens at runtime based on real data values
+    if user["is_premium"]:
+        result = await process_premium_user(user)
+    else:
+        result = await process_standard_user(user)
+    return result
+```
+
+---
+
+## 🎨 Visualization Telemetry
+
+Generating an interactive, visual representation of your executed workflow is a single method call:
+
+```python
+# Save interactive HTML dashboard
+run.visualize("workflow_run.html")
+```
+
+Open `workflow_run.html` in any browser to get a premium dark-mode interface where you can:
+1. Pan and zoom around the execution DAG.
+2. Review node colors indicating statuses: **Green (Success)**, **Red (Failed)**, **Blue (Running)**, **Grey (Pending)**.
+3. Click any node to slide open a telemetry inspect panel containing:
+   - Inputs and outputs
+   - Time elapsed, start/end timestamps
+   - Retry counts and exceptions
+
+---
+
+## ⚙️ Configuration Properties
+
+The `@task` decorator accepts the following metadata options:
+
+| Property | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `name` | `str` | *Function Name* | Identifier for the task (used in dashboard and graphs). |
+| `retries` | `int` | `0` | Number of attempts to retry if the function raises an exception. |
+| `retry_delay` | `float` | `1.0` | Initial delay (seconds) before attempting a retry. |
+| `backoff_factor`| `float` | `2.0` | Exponential multiplier for consecutive retries (delay * backoff_factor^attempt). |
+| `timeout` | `float` | `None` | Max seconds before cancelling execution and marking the task as failed. |
+
+---
+
+## 🧪 Running Tests
+
+To run the unit and integration test suite, install development dependencies and run `pytest`:
+
+```bash
+pip install -e ".[dev]"
+pytest tests/
+```
+
+---
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for details.

pyrelay_workflow-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyrelay/__init__.py,sha256=4sbmriHWaWkETyLrSzKHYJkN6Y9iioCMKOPS1qnLHE0,333
+pyrelay/core.py,sha256=DqCj4SH4tpaQSIig5LDNIHQH8O_xg98iLXWiwwdy_Qc,7317
+pyrelay/dashboard.py,sha256=ne7-nfUp4wCgfa-pdJAgSV6ZaF6lIbOTkWLTgMupxt8,8978
+pyrelay/engine.py,sha256=HDMjR99MSeXiEkbbfkonBB5pp4w6eCgpEPblecRr-9s,8452
+pyrelay/exceptions.py,sha256=biT9hm5TtDcU1SY316WLC6PX70TVEB3hG0G0s3nanIM,693
+pyrelay/visualizer.py,sha256=6LcRUp-xsoVCSzij-P5NXhXFOjdksmpMqnr5w6sts94,16752
+pyrelay_workflow-0.1.0.dist-info/licenses/LICENSE,sha256=c86TVJSMxIYa5MVAOiXlAkWw5dxf4my46bpPHew0jPA,1066
+pyrelay_workflow-0.1.0.dist-info/METADATA,sha256=fnI6_LJ82qUEaaNP_WpAqGc-RgNZRQbl4vL0SCcOwGg,5820
+pyrelay_workflow-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyrelay_workflow-0.1.0.dist-info/top_level.txt,sha256=8HaSBt3fHoKosrbC0-WDSG9L2dJD3CTFNrusjhly9rs,8
+pyrelay_workflow-0.1.0.dist-info/RECORD,,

pyrelay_workflow-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyrelay_workflow-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Developer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyrelay_workflow-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyrelay