pyworkflow-engine 0.1.7__py3-none-any.whl

dashboard/backend/app/__init__.py

@@ -0,0 +1 @@
+"""PyWorkflow Dashboard Backend."""

dashboard/backend/app/config.py

@@ -0,0 +1,32 @@
+"""Dashboard configuration using pydantic-settings."""
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Dashboard settings loaded from environment variables."""
+
+    # PyWorkflow configuration
+    pyworkflow_config_path: str | None = None  # Path to pyworkflow.config.yaml
+
+    # Storage configuration (fallback if pyworkflow config not set)
+    storage_type: str = "file"
+    storage_path: str = "./pyworkflow_data"
+
+    # Server configuration
+    host: str = "0.0.0.0"
+    port: int = 8585
+
+    # CORS configuration
+    cors_origins: list[str] = ["http://localhost:5173", "http://localhost:3000"]
+
+    # Debug mode
+    debug: bool = False
+
+    class Config:
+        env_prefix = "DASHBOARD_"
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+
+
+settings = Settings()

dashboard/backend/app/controllers/__init__.py

@@ -0,0 +1,6 @@
+"""Controllers layer."""
+
+from app.controllers.run_controller import RunController
+from app.controllers.workflow_controller import WorkflowController
+
+__all__ = ["WorkflowController", "RunController"]

dashboard/backend/app/controllers/run_controller.py

@@ -0,0 +1,86 @@
+"""Controller for workflow run endpoints."""
+
+from datetime import datetime
+
+from app.repositories.run_repository import RunRepository
+from app.schemas.event import EventListResponse
+from app.schemas.run import RunDetailResponse, RunListResponse, StartRunRequest, StartRunResponse
+from app.services.run_service import RunService
+from pyworkflow.storage.base import StorageBackend
+
+
+class RunController:
+    """Controller handling workflow run-related requests."""
+
+    def __init__(self, storage: StorageBackend):
+        """Initialize controller with storage backend.
+
+        Args:
+            storage: PyWorkflow storage backend.
+        """
+        self.repository = RunRepository(storage)
+        self.service = RunService(self.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.
+            start_time: Filter runs started at or after this time.
+            end_time: Filter runs started before this time.
+            limit: Maximum results.
+            cursor: Run ID to start after (for pagination).
+
+        Returns:
+            RunListResponse with matching runs and next_cursor.
+        """
+        return await self.service.list_runs(
+            query=query,
+            status=status,
+            start_time=start_time,
+            end_time=end_time,
+            limit=limit,
+            cursor=cursor,
+        )
+
+    async def get_run(self, run_id: str) -> RunDetailResponse | None:
+        """Get detailed information about a run.
+
+        Args:
+            run_id: The run ID.
+
+        Returns:
+            RunDetailResponse if found, None otherwise.
+        """
+        return await self.service.get_run(run_id)
+
+    async def get_events(self, run_id: str) -> EventListResponse:
+        """Get events for a run.
+
+        Args:
+            run_id: The run ID.
+
+        Returns:
+            EventListResponse with run events.
+        """
+        return await self.service.get_events(run_id)
+
+    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.
+        """
+        return await self.service.start_run(request)

dashboard/backend/app/controllers/workflow_controller.py

@@ -0,0 +1,33 @@
+"""Controller for workflow endpoints."""
+
+from app.repositories.workflow_repository import WorkflowRepository
+from app.schemas.workflow import WorkflowListResponse, WorkflowResponse
+from app.services.workflow_service import WorkflowService
+
+
+class WorkflowController:
+    """Controller handling workflow-related requests."""
+
+    def __init__(self):
+        """Initialize controller with service layer."""
+        self.repository = WorkflowRepository()
+        self.service = WorkflowService(self.repository)
+
+    def list_workflows(self) -> WorkflowListResponse:
+        """Get all registered workflows.
+
+        Returns:
+            WorkflowListResponse with all workflows.
+        """
+        return self.service.list_workflows()
+
+    def get_workflow(self, name: str) -> WorkflowResponse | None:
+        """Get a specific workflow by name.
+
+        Args:
+            name: Workflow name.
+
+        Returns:
+            WorkflowResponse if found, None otherwise.
+        """
+        return self.service.get_workflow(name)

dashboard/backend/app/dependencies/__init__.py

@@ -0,0 +1,5 @@
+"""FastAPI dependencies."""
+
+from app.dependencies.storage import get_storage
+
+__all__ = ["get_storage"]

dashboard/backend/app/dependencies/storage.py

@@ -0,0 +1,50 @@
+"""Storage dependency for FastAPI."""
+
+from app.config import settings
+from pyworkflow import get_storage as pyworkflow_get_storage
+from pyworkflow.storage.base import StorageBackend
+from pyworkflow.storage.file import FileStorageBackend
+from pyworkflow.storage.memory import InMemoryStorageBackend
+
+_storage_instance: StorageBackend | None = None
+
+
+def reset_storage_cache() -> None:
+    """Reset the cached storage instance.
+
+    Called during application startup to ensure fresh initialization
+    after pyworkflow configuration is loaded.
+    """
+    global _storage_instance
+    _storage_instance = None
+
+
+async def get_storage() -> StorageBackend:
+    """Get or create the storage backend instance.
+
+    First tries to get storage from pyworkflow configuration.
+    Falls back to creating based on dashboard settings.
+    """
+    global _storage_instance
+
+    if _storage_instance is None:
+        # Try to get from pyworkflow config first
+        storage = pyworkflow_get_storage()
+
+        if storage is None:
+            # Create based on dashboard config
+            if settings.storage_type == "file":
+                storage = FileStorageBackend(settings.storage_path)
+            elif settings.storage_type == "sqlite":
+                from pyworkflow.storage.sqlite import SQLiteStorageBackend
+
+                db_path = f"{settings.storage_path}/pyworkflow.db"
+                storage = SQLiteStorageBackend(db_path)
+            elif settings.storage_type == "memory":
+                storage = InMemoryStorageBackend()
+            else:
+                raise ValueError(f"Unknown storage type: {settings.storage_type}")
+
+        _storage_instance = storage
+
+    return _storage_instance

dashboard/backend/app/repositories/__init__.py

@@ -0,0 +1,6 @@
+"""Repository layer."""
+
+from app.repositories.run_repository import RunRepository
+from app.repositories.workflow_repository import WorkflowRepository
+
+__all__ = ["WorkflowRepository", "RunRepository"]

dashboard/backend/app/repositories/run_repository.py

@@ -0,0 +1,80 @@
+"""Repository for workflow run data access."""
+
+from datetime import datetime
+
+from pyworkflow.engine.events import Event
+from pyworkflow.storage.base import StorageBackend
+from pyworkflow.storage.schemas import (
+    RunStatus,
+    WorkflowRun,
+)
+
+
+class RunRepository:
+    """Repository for accessing workflow run data via pyworkflow storage."""
+
+    def __init__(self, storage: StorageBackend):
+        """Initialize with a storage backend.
+
+        Args:
+            storage: PyWorkflow storage backend instance.
+        """
+        self.storage = storage
+
+    async def list_runs(
+        self,
+        query: str | None = None,
+        status: RunStatus | None = None,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> tuple[list[WorkflowRun], str | None]:
+        """List workflow runs with optional filtering and cursor-based pagination.
+
+        Args:
+            query: Case-insensitive search in workflow name and input kwargs.
+            status: Filter by run status.
+            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:
+            Tuple of (list of workflow runs, next_cursor or None).
+        """
+        return await self.storage.list_runs(
+            query=query,
+            status=status,
+            start_time=start_time,
+            end_time=end_time,
+            limit=limit,
+            cursor=cursor,
+        )
+
+    async def get_run(self, run_id: str) -> WorkflowRun | None:
+        """Get a workflow run by ID.
+
+        Args:
+            run_id: The run ID.
+
+        Returns:
+            WorkflowRun if found, None otherwise.
+        """
+        return await self.storage.get_run(run_id)
+
+    async def get_events(
+        self,
+        run_id: str,
+        event_types: list[str] | None = None,
+    ) -> list[Event]:
+        """Get all events for a workflow run.
+
+        Args:
+            run_id: The run ID.
+            event_types: Optional filter by event types.
+
+        Returns:
+            List of events ordered by sequence.
+        """
+        return await self.storage.get_events(run_id, event_types=event_types)

dashboard/backend/app/repositories/workflow_repository.py

@@ -0,0 +1,27 @@
+"""Repository for workflow metadata access."""
+
+from pyworkflow import get_workflow, list_workflows
+from pyworkflow.core.registry import WorkflowMetadata
+
+
+class WorkflowRepository:
+    """Repository for accessing registered workflow metadata."""
+
+    def list_all(self) -> dict[str, WorkflowMetadata]:
+        """Get all registered workflows.
+
+        Returns:
+            Dictionary mapping workflow names to their metadata.
+        """
+        return list_workflows()
+
+    def get_by_name(self, name: str) -> WorkflowMetadata | None:
+        """Get a specific workflow by name.
+
+        Args:
+            name: The workflow name.
+
+        Returns:
+            WorkflowMetadata if found, None otherwise.
+        """
+        return get_workflow(name)

dashboard/backend/app/rest/__init__.py

@@ -0,0 +1,8 @@
+"""REST API routes."""
+
+from fastapi import APIRouter
+
+from app.rest.v1 import router as v1_router
+
+router = APIRouter()
+router.include_router(v1_router, prefix="/api/v1")

dashboard/backend/app/rest/v1/__init__.py

@@ -0,0 +1,12 @@
+"""V1 API routes."""
+
+from fastapi import APIRouter
+
+from app.rest.v1.health import router as health_router
+from app.rest.v1.runs import router as runs_router
+from app.rest.v1.workflows import router as workflows_router
+
+router = APIRouter()
+router.include_router(health_router, tags=["health"])
+router.include_router(workflows_router, prefix="/workflows", tags=["workflows"])
+router.include_router(runs_router, prefix="/runs", tags=["runs"])

dashboard/backend/app/rest/v1/health.py

@@ -0,0 +1,33 @@
+"""Health check endpoint."""
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+
+from app.dependencies import get_storage
+from pyworkflow.storage.base import StorageBackend
+
+router = APIRouter()
+
+
+class HealthResponse(BaseModel):
+    """Health check response."""
+
+    status: str
+    storage_healthy: bool
+
+
+@router.get("/health", response_model=HealthResponse)
+async def health_check(
+    storage: StorageBackend = Depends(get_storage),
+) -> HealthResponse:
+    """Check API and storage health.
+
+    Returns:
+        HealthResponse with status information.
+    """
+    storage_healthy = await storage.health_check()
+
+    return HealthResponse(
+        status="healthy" if storage_healthy else "degraded",
+        storage_healthy=storage_healthy,
+    )

dashboard/backend/app/rest/v1/runs.py

@@ -0,0 +1,133 @@
+"""Workflow run endpoints."""
+
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from app.controllers.run_controller import RunController
+from app.dependencies import get_storage
+from app.schemas.event import EventListResponse
+from app.schemas.run import RunDetailResponse, RunListResponse, StartRunRequest, StartRunResponse
+from pyworkflow.storage.base import StorageBackend
+
+router = APIRouter()
+
+
+@router.get("", response_model=RunListResponse)
+async def list_runs(
+    query: str | None = Query(
+        None, description="Search in workflow name and input kwargs (case-insensitive)"
+    ),
+    status: str | None = Query(
+        None,
+        description="Filter by status (pending, running, suspended, completed, failed, interrupted, cancelled)",
+    ),
+    start_time: datetime | None = Query(
+        None, description="Filter runs started at or after this time (ISO 8601)"
+    ),
+    end_time: datetime | None = Query(
+        None, description="Filter runs started before this time (ISO 8601)"
+    ),
+    limit: int = Query(100, ge=1, le=1000, description="Maximum results"),
+    cursor: str | None = Query(None, description="Run ID to start after (for pagination)"),
+    storage: StorageBackend = Depends(get_storage),
+) -> 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 run status.
+        start_time: Filter runs started at or after this time.
+        end_time: Filter runs started before this time.
+        limit: Maximum number of results (1-1000).
+        cursor: Run ID to start after (for pagination).
+        storage: Storage backend (injected).
+
+    Returns:
+        RunListResponse with matching runs and next_cursor.
+    """
+    controller = RunController(storage)
+    return await controller.list_runs(
+        query=query,
+        status=status,
+        start_time=start_time,
+        end_time=end_time,
+        limit=limit,
+        cursor=cursor,
+    )
+
+
+@router.post("", response_model=StartRunResponse, status_code=201)
+async def start_run(
+    request: StartRunRequest,
+    storage: StorageBackend = Depends(get_storage),
+) -> StartRunResponse:
+    """Start a new workflow run.
+
+    Args:
+        request: Start run request with workflow name and kwargs.
+        storage: Storage backend (injected).
+
+    Returns:
+        StartRunResponse with run_id and workflow_name.
+
+    Raises:
+        HTTPException: 404 if workflow not found, 400 for validation errors.
+    """
+    controller = RunController(storage)
+    try:
+        return await controller.start_run(request)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/{run_id}", response_model=RunDetailResponse)
+async def get_run(
+    run_id: str,
+    storage: StorageBackend = Depends(get_storage),
+) -> RunDetailResponse:
+    """Get detailed information about a workflow run.
+
+    Args:
+        run_id: The run ID.
+        storage: Storage backend (injected).
+
+    Returns:
+        RunDetailResponse with run details.
+
+    Raises:
+        HTTPException: 404 if run not found.
+    """
+    controller = RunController(storage)
+    run = await controller.get_run(run_id)
+
+    if run is None:
+        raise HTTPException(status_code=404, detail=f"Run '{run_id}' not found")
+
+    return run
+
+
+@router.get("/{run_id}/events", response_model=EventListResponse)
+async def get_run_events(
+    run_id: str,
+    storage: StorageBackend = Depends(get_storage),
+) -> EventListResponse:
+    """Get all events for a workflow run.
+
+    Args:
+        run_id: The run ID.
+        storage: Storage backend (injected).
+
+    Returns:
+        EventListResponse with run events.
+    """
+    controller = RunController(storage)
+
+    # Verify run exists
+    run = await controller.get_run(run_id)
+    if run is None:
+        raise HTTPException(status_code=404, detail=f"Run '{run_id}' not found")
+
+    return await controller.get_events(run_id)

dashboard/backend/app/rest/v1/workflows.py

@@ -0,0 +1,41 @@
+"""Workflow endpoints."""
+
+from fastapi import APIRouter, HTTPException
+
+from app.controllers.workflow_controller import WorkflowController
+from app.schemas.workflow import WorkflowListResponse, WorkflowResponse
+
+router = APIRouter()
+
+
+@router.get("", response_model=WorkflowListResponse)
+async def list_workflows() -> WorkflowListResponse:
+    """List all registered workflows.
+
+    Returns:
+        WorkflowListResponse with all registered workflows.
+    """
+    controller = WorkflowController()
+    return controller.list_workflows()
+
+
+@router.get("/{name}", response_model=WorkflowResponse)
+async def get_workflow(name: str) -> WorkflowResponse:
+    """Get a specific workflow by name.
+
+    Args:
+        name: Workflow name.
+
+    Returns:
+        WorkflowResponse with workflow details.
+
+    Raises:
+        HTTPException: 404 if workflow not found.
+    """
+    controller = WorkflowController()
+    workflow = controller.get_workflow(name)
+
+    if workflow is None:
+        raise HTTPException(status_code=404, detail=f"Workflow '{name}' not found")
+
+    return workflow

dashboard/backend/app/schemas/__init__.py

@@ -0,0 +1,23 @@
+"""Pydantic schemas for API request/response models."""
+
+from app.schemas.common import PaginatedResponse
+from app.schemas.event import EventListResponse, EventResponse
+from app.schemas.hook import HookListResponse, HookResponse
+from app.schemas.run import RunDetailResponse, RunListResponse, RunResponse
+from app.schemas.step import StepListResponse, StepResponse
+from app.schemas.workflow import WorkflowListResponse, WorkflowResponse
+
+__all__ = [
+    "PaginatedResponse",
+    "WorkflowResponse",
+    "WorkflowListResponse",
+    "RunResponse",
+    "RunDetailResponse",
+    "RunListResponse",
+    "EventResponse",
+    "EventListResponse",
+    "StepResponse",
+    "StepListResponse",
+    "HookResponse",
+    "HookListResponse",
+]

dashboard/backend/app/schemas/common.py

@@ -0,0 +1,16 @@
+"""Common schema types."""
+
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+T = TypeVar("T")
+
+
+class PaginatedResponse(BaseModel, Generic[T]):
+    """Base paginated response model."""
+
+    items: list[T]
+    count: int
+    limit: int = 100
+    offset: int = 0

dashboard/backend/app/schemas/event.py

@@ -0,0 +1,24 @@
+"""Event response schemas."""
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class EventResponse(BaseModel):
+    """Response model for a workflow event."""
+
+    event_id: str
+    run_id: str
+    type: str
+    timestamp: datetime
+    sequence: int | None = None
+    data: dict[str, Any] = {}
+
+
+class EventListResponse(BaseModel):
+    """Response model for listing events."""
+
+    items: list[EventResponse]
+    count: int

dashboard/backend/app/schemas/hook.py

@@ -0,0 +1,25 @@
+"""Hook response schemas."""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class HookResponse(BaseModel):
+    """Response model for a hook."""
+
+    hook_id: str
+    run_id: str
+    name: str | None = None
+    status: str
+    created_at: datetime
+    received_at: datetime | None = None
+    expires_at: datetime | None = None
+    has_payload: bool = False
+
+
+class HookListResponse(BaseModel):
+    """Response model for listing hooks."""
+
+    items: list[HookResponse]
+    count: int