pyworkflow-engine 0.1.7__py3-none-any.whl → 0.1.10__py3-none-any.whl

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

@@ -1,133 +0,0 @@
-"""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

@@ -1,41 +0,0 @@
-"""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

@@ -1,23 +0,0 @@
-"""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

@@ -1,16 +0,0 @@
-"""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

@@ -1,24 +0,0 @@
-"""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

@@ -1,25 +0,0 @@
-"""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

dashboard/backend/app/schemas/run.py

@@ -1,54 +0,0 @@
-"""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

@@ -1,28 +0,0 @@
-"""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

@@ -1,31 +0,0 @@
-"""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

@@ -1,87 +0,0 @@
-"""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

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