pyworkflow-engine 0.1.7__py3-none-any.whl

dashboard/backend/app/schemas/run.py

@@ -0,0 +1,54 @@
+"""Workflow run response schemas."""
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class RunResponse(BaseModel):
+    """Response model for a workflow run."""
+
+    run_id: str
+    workflow_name: str
+    status: str
+    created_at: datetime
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    duration_seconds: float | None = None
+    error: str | None = None
+    recovery_attempts: int = 0
+
+
+class RunDetailResponse(RunResponse):
+    """Detailed response model for a workflow run."""
+
+    input_args: Any | None = None
+    input_kwargs: Any | None = None
+    result: Any | None = None
+    metadata: dict[str, Any] = {}
+    max_duration: str | None = None
+    max_recovery_attempts: int = 3
+
+
+class RunListResponse(BaseModel):
+    """Response model for listing runs."""
+
+    items: list[RunResponse]
+    count: int
+    limit: int = 100
+    next_cursor: str | None = None
+
+
+class StartRunRequest(BaseModel):
+    """Request model for starting a new workflow run."""
+
+    workflow_name: str
+    kwargs: dict[str, Any] = {}
+
+
+class StartRunResponse(BaseModel):
+    """Response model for a newly started workflow run."""
+
+    run_id: str
+    workflow_name: str

dashboard/backend/app/schemas/step.py

@@ -0,0 +1,28 @@
+"""Step execution response schemas."""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class StepResponse(BaseModel):
+    """Response model for a step execution."""
+
+    step_id: str
+    run_id: str
+    step_name: str
+    status: str
+    attempt: int = 1
+    max_retries: int = 3
+    created_at: datetime
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    duration_seconds: float | None = None
+    error: str | None = None
+
+
+class StepListResponse(BaseModel):
+    """Response model for listing steps."""
+
+    items: list[StepResponse]
+    count: int

dashboard/backend/app/schemas/workflow.py

@@ -0,0 +1,31 @@
+"""Workflow-related response schemas."""
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class WorkflowParameter(BaseModel):
+    """Response model for a workflow parameter."""
+
+    name: str
+    type: str  # "string", "number", "boolean", "object", "array", "any"
+    required: bool
+    default: Any | None = None
+
+
+class WorkflowResponse(BaseModel):
+    """Response model for a registered workflow."""
+
+    name: str
+    description: str | None = None
+    max_duration: str | None = None
+    tags: list[str] = []
+    parameters: list[WorkflowParameter] = []
+
+
+class WorkflowListResponse(BaseModel):
+    """Response model for listing workflows."""
+
+    items: list[WorkflowResponse]
+    count: int

dashboard/backend/app/server.py

@@ -0,0 +1,87 @@
+"""FastAPI application factory."""
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.config import settings
+from app.rest import router as api_router
+
+
+def _initialize_pyworkflow() -> None:
+    """Initialize pyworkflow configuration and discover workflows.
+
+    Priority:
+    1. If pyworkflow_config_path is set, load from that path (includes discovery)
+    2. Otherwise, load from pyworkflow.config.yaml in cwd and discover workflows
+    """
+    import pyworkflow
+
+    if settings.pyworkflow_config_path:
+        # configure_from_yaml automatically discovers workflows
+        pyworkflow.configure_from_yaml(settings.pyworkflow_config_path)
+    else:
+        # Load config without discovery, then discover from cwd config
+        pyworkflow.get_config()
+        # Discover workflows from pyworkflow.config.yaml in cwd
+        pyworkflow.discover_workflows()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Application lifespan handler.
+
+    Startup: Initialize pyworkflow configuration
+    Shutdown: (cleanup if needed in future)
+    """
+    # Startup
+    _initialize_pyworkflow()
+
+    # Reset cached storage instance to ensure fresh initialization
+    from app.dependencies.storage import get_storage, reset_storage_cache
+
+    reset_storage_cache()
+
+    # Initialize and connect storage backend
+    storage = await get_storage()
+    if hasattr(storage, "connect"):
+        await storage.connect()
+    if hasattr(storage, "initialize"):
+        await storage.initialize()
+
+    yield
+
+    # Shutdown - disconnect storage
+    if hasattr(storage, "disconnect"):
+        await storage.disconnect()
+
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application."""
+    app = FastAPI(
+        title="PyWorkflow Dashboard API",
+        description="REST API for monitoring PyWorkflow workflows",
+        version="0.1.0",
+        docs_url="/docs",
+        redoc_url="/redoc",
+        lifespan=lifespan,
+    )
+
+    # Configure CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=settings.cors_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include API routes
+    app.include_router(api_router)
+
+    return app
+
+
+app = create_app()

dashboard/backend/app/services/__init__.py

@@ -0,0 +1,6 @@
+"""Services layer."""
+
+from app.services.run_service import RunService
+from app.services.workflow_service import WorkflowService
+
+__all__ = ["WorkflowService", "RunService"]

dashboard/backend/app/services/run_service.py

@@ -0,0 +1,240 @@
+"""Service layer for workflow run operations."""
+
+import json
+from datetime import UTC, datetime
+from typing import Any
+
+import pyworkflow
+from app.repositories.run_repository import RunRepository
+from app.schemas.event import EventListResponse, EventResponse
+from app.schemas.run import (
+    RunDetailResponse,
+    RunListResponse,
+    RunResponse,
+    StartRunRequest,
+    StartRunResponse,
+)
+from pyworkflow.storage.schemas import RunStatus, WorkflowRun
+
+
+class RunService:
+    """Service for workflow run-related business logic."""
+
+    def __init__(self, repository: RunRepository):
+        """Initialize with run repository.
+
+        Args:
+            repository: RunRepository instance.
+        """
+        self.repository = repository
+
+    async def list_runs(
+        self,
+        query: str | None = None,
+        status: str | None = None,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> RunListResponse:
+        """List workflow runs with optional filtering and cursor-based pagination.
+
+        Args:
+            query: Case-insensitive search in workflow name and input kwargs.
+            status: Filter by status string.
+            start_time: Filter runs started at or after this time.
+            end_time: Filter runs started before this time.
+            limit: Maximum number of results.
+            cursor: Run ID to start after (for pagination).
+
+        Returns:
+            RunListResponse with list of runs and next_cursor.
+        """
+        status_enum = RunStatus(status) if status else None
+
+        runs, next_cursor = await self.repository.list_runs(
+            query=query,
+            status=status_enum,
+            start_time=start_time,
+            end_time=end_time,
+            limit=limit,
+            cursor=cursor,
+        )
+
+        items = [self._run_to_response(run) for run in runs]
+
+        return RunListResponse(
+            items=items,
+            count=len(items),
+            limit=limit,
+            next_cursor=next_cursor,
+        )
+
+    async def get_run(self, run_id: str) -> RunDetailResponse | None:
+        """Get detailed information about a workflow run.
+
+        Args:
+            run_id: The run ID.
+
+        Returns:
+            RunDetailResponse if found, None otherwise.
+        """
+        run = await self.repository.get_run(run_id)
+
+        if run is None:
+            return None
+
+        return self._run_to_detail_response(run)
+
+    async def get_events(self, run_id: str) -> EventListResponse:
+        """Get all events for a workflow run.
+
+        Args:
+            run_id: The run ID.
+
+        Returns:
+            EventListResponse with list of events.
+        """
+        events = await self.repository.get_events(run_id)
+
+        items = [
+            EventResponse(
+                event_id=event.event_id,
+                run_id=event.run_id,
+                type=event.type.value,
+                timestamp=event.timestamp,
+                sequence=event.sequence,
+                data=event.data,
+            )
+            for event in events
+        ]
+
+        return EventListResponse(
+            items=items,
+            count=len(items),
+        )
+
+    def _run_to_response(self, run: WorkflowRun) -> RunResponse:
+        """Convert WorkflowRun to RunResponse.
+
+        Args:
+            run: WorkflowRun instance.
+
+        Returns:
+            RunResponse instance.
+        """
+        return RunResponse(
+            run_id=run.run_id,
+            workflow_name=run.workflow_name,
+            status=run.status.value,
+            created_at=run.created_at,
+            started_at=run.started_at,
+            completed_at=run.completed_at,
+            duration_seconds=self._calculate_duration(run.started_at, run.completed_at),
+            error=run.error,
+            recovery_attempts=run.recovery_attempts,
+        )
+
+    def _run_to_detail_response(self, run: WorkflowRun) -> RunDetailResponse:
+        """Convert WorkflowRun to RunDetailResponse.
+
+        Args:
+            run: WorkflowRun instance.
+
+        Returns:
+            RunDetailResponse instance.
+        """
+        # Parse JSON strings for input/result
+        input_args = self._safe_json_parse(run.input_args)
+        input_kwargs = self._safe_json_parse(run.input_kwargs)
+        result = self._safe_json_parse(run.result) if run.result else None
+
+        return RunDetailResponse(
+            run_id=run.run_id,
+            workflow_name=run.workflow_name,
+            status=run.status.value,
+            created_at=run.created_at,
+            started_at=run.started_at,
+            completed_at=run.completed_at,
+            duration_seconds=self._calculate_duration(run.started_at, run.completed_at),
+            error=run.error,
+            recovery_attempts=run.recovery_attempts,
+            input_args=input_args,
+            input_kwargs=input_kwargs,
+            result=result,
+            metadata=run.metadata,
+            max_duration=run.max_duration,
+            max_recovery_attempts=run.max_recovery_attempts,
+        )
+
+    def _calculate_duration(
+        self,
+        started_at: datetime | None,
+        completed_at: datetime | None,
+    ) -> float | None:
+        """Calculate duration in seconds.
+
+        Args:
+            started_at: Start timestamp.
+            completed_at: Completion timestamp.
+
+        Returns:
+            Duration in seconds, or None if not calculable.
+        """
+        if started_at is None:
+            return None
+
+        end_time = completed_at or datetime.now(UTC)
+
+        # Handle timezone-naive datetimes
+        if started_at.tzinfo is None:
+            started_at = started_at.replace(tzinfo=UTC)
+        if end_time.tzinfo is None:
+            end_time = end_time.replace(tzinfo=UTC)
+
+        return (end_time - started_at).total_seconds()
+
+    def _safe_json_parse(self, value: str | None) -> Any:
+        """Safely parse a JSON string.
+
+        Args:
+            value: JSON string or None.
+
+        Returns:
+            Parsed value or the original string if parsing fails.
+        """
+        if value is None:
+            return None
+
+        try:
+            return json.loads(value)
+        except (json.JSONDecodeError, TypeError):
+            return value
+
+    async def start_run(self, request: StartRunRequest) -> StartRunResponse:
+        """Start a new workflow run.
+
+        Args:
+            request: The start run request containing workflow name and kwargs.
+
+        Returns:
+            StartRunResponse with run_id and workflow_name.
+
+        Raises:
+            ValueError: If workflow not found.
+        """
+        # Get the workflow metadata
+        workflow_meta = pyworkflow.get_workflow(request.workflow_name)
+        if workflow_meta is None:
+            raise ValueError(f"Workflow '{request.workflow_name}' not found")
+
+        # Start the workflow using pyworkflow.start()
+        run_id = await pyworkflow.start(
+            workflow_meta.func,
+            **request.kwargs,
+        )
+
+        return StartRunResponse(
+            run_id=run_id,
+            workflow_name=request.workflow_name,
+        )

dashboard/backend/app/services/workflow_service.py

@@ -0,0 +1,155 @@
+"""Service layer for workflow operations."""
+
+import inspect
+from typing import Any, get_origin, get_type_hints
+
+from app.repositories.workflow_repository import WorkflowRepository
+from app.schemas.workflow import (
+    WorkflowListResponse,
+    WorkflowParameter,
+    WorkflowResponse,
+)
+
+
+def _get_type_name(type_hint: Any) -> str:
+    """Convert a Python type hint to a simple type name for the frontend.
+
+    Args:
+        type_hint: The type hint to convert.
+
+    Returns:
+        A string representing the type ("string", "number", "boolean", "array", "object", "any").
+    """
+    if type_hint is Any or type_hint is inspect.Parameter.empty:
+        return "any"
+
+    # Handle None type
+    if type_hint is type(None):
+        return "any"
+
+    # Get the origin for generic types (e.g., list[str] -> list)
+    origin = get_origin(type_hint)
+    if origin is not None:
+        if origin is list:
+            return "array"
+        if origin is dict:
+            return "object"
+        # Union types (Optional, etc.)
+        if origin is type(None):
+            return "any"
+
+    # Handle basic types
+    if hasattr(type_hint, "__name__"):
+        type_name = type_hint.__name__
+        if type_name == "str":
+            return "string"
+        if type_name in ("int", "float"):
+            return "number"
+        if type_name == "bool":
+            return "boolean"
+        if type_name == "list":
+            return "array"
+        if type_name == "dict":
+            return "object"
+
+    return "any"
+
+
+def _extract_workflow_parameters(func: Any) -> list[WorkflowParameter]:
+    """Extract parameter information from a workflow function.
+
+    Args:
+        func: The workflow function to inspect.
+
+    Returns:
+        List of WorkflowParameter objects.
+    """
+    sig = inspect.signature(func)
+    params = []
+
+    # Try to get type hints
+    try:
+        hints = get_type_hints(func)
+    except Exception:
+        hints = {}
+
+    for param_name, param in sig.parameters.items():
+        # Skip *args and **kwargs
+        if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            continue
+
+        type_hint = hints.get(param_name, Any)
+        has_default = param.default is not inspect.Parameter.empty
+
+        # Serialize the default value
+        default_value = None
+        if has_default:
+            default_value = param.default
+
+        param_info = WorkflowParameter(
+            name=param_name,
+            type=_get_type_name(type_hint),
+            required=not has_default,
+            default=default_value,
+        )
+        params.append(param_info)
+
+    return params
+
+
+class WorkflowService:
+    """Service for workflow-related business logic."""
+
+    def __init__(self, repository: WorkflowRepository):
+        """Initialize with workflow repository.
+
+        Args:
+            repository: WorkflowRepository instance.
+        """
+        self.repository = repository
+
+    def list_workflows(self) -> WorkflowListResponse:
+        """Get all registered workflows.
+
+        Returns:
+            WorkflowListResponse with list of workflows.
+        """
+        workflows = self.repository.list_all()
+
+        items = [
+            WorkflowResponse(
+                name=name,
+                description=metadata.description,
+                max_duration=metadata.max_duration,
+                tags=metadata.tags or [],
+                parameters=_extract_workflow_parameters(metadata.original_func),
+            )
+            for name, metadata in workflows.items()
+        ]
+
+        return WorkflowListResponse(
+            items=items,
+            count=len(items),
+        )
+
+    def get_workflow(self, name: str) -> WorkflowResponse | None:
+        """Get a specific workflow by name.
+
+        Args:
+            name: Workflow name.
+
+        Returns:
+            WorkflowResponse if found, None otherwise.
+        """
+        metadata = self.repository.get_by_name(name)
+
+        if metadata is None:
+            return None
+
+        return WorkflowResponse(
+            name=metadata.name,
+            description=metadata.description,
+            max_duration=metadata.max_duration,
+            tags=metadata.tags or [],
+            parameters=_extract_workflow_parameters(metadata.original_func),
+        )

dashboard/backend/main.py

@@ -0,0 +1,18 @@
+"""CLI entry point for the dashboard backend server."""
+
+import uvicorn
+from app.config import settings
+
+
+def main():
+    """Run the dashboard backend server."""
+    uvicorn.run(
+        "app.server:app",
+        host=settings.host,
+        port=settings.port,
+        reload=settings.debug,
+    )
+
+
+if __name__ == "__main__":
+    main()