planar 0.5.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

planar/routers/test_workflow_router.py

@@ -1,7 +1,9 @@
+import asyncio
 from uuid import UUID, uuid4
 
 import pytest
 from pydantic import BaseModel, Field
+from sqlalchemy.ext.asyncio import AsyncEngine
 from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
@@ -10,12 +12,19 @@ from examples.expense_approval_workflow.models import (
     ExpenseStatus,
 )
 from planar import PlanarApp, get_session, sqlite_config
+from planar.db import new_session
 from planar.files.models import PlanarFile, PlanarFileMetadata
 from planar.files.storage.base import Storage
 from planar.testing.planar_test_client import PlanarTestClient
 from planar.testing.workflow_observer import WorkflowObserver
 from planar.workflows import step, workflow
-from planar.workflows.models import StepType, Workflow, WorkflowStatus, WorkflowStep
+from planar.workflows.models import (
+    StepStatus,
+    StepType,
+    Workflow,
+    WorkflowStatus,
+    WorkflowStep,
+)
 
 # ------ SETUP ------
 
@@ -50,6 +59,40 @@ async def validate_expense(expense_id: str):
         raise ValueError(f"Expense {expense_id} is not in SUBMITTED status")
 
 
+@step()
+async def dummy_step_1():
+    pass
+
+
+@step()
+async def dummy_step_2():
+    pass
+
+
+@step()
+async def dummy_step_3():
+    pass
+
+
+@step(display_name="failing_step")
+async def failing_step():
+    raise ValueError("This step is designed to fail")
+
+
+@workflow(name="successful_workflow_3_steps")
+async def successful_workflow_3_steps():
+    await dummy_step_1()
+    await dummy_step_2()
+    await dummy_step_3()
+
+
+@workflow(name="failing_workflow_3_steps")
+async def failing_workflow_3_steps():
+    await dummy_step_1()
+    await failing_step()
+    await dummy_step_3()
+
+
 class FileProcessingResult(BaseModel):
     """Result of processing a text file."""
 
@@ -92,6 +135,8 @@ def app_fixture():
     # Re-register workflows since ObjectRegistry gets reset before each test
     app.register_workflow(expense_approval_workflow)
     app.register_workflow(file_processing_workflow)
+    app.register_workflow(successful_workflow_3_steps)
+    app.register_workflow(failing_workflow_3_steps)
     yield app
 
 
@@ -125,6 +170,72 @@ async def planar_file(storage: Storage) -> PlanarFile:
     )
 
 
+async def create_test_workflow_run(
+    engine: AsyncEngine,
+    workflow_name: str,
+    status: WorkflowStatus,
+    completed_steps: int = 0,
+    total_steps: int = 0,
+    error: dict | None = None,
+) -> Workflow:
+    """Helper to directly create a workflow run and its steps in the DB."""
+    async with new_session(engine) as session:
+        workflow = Workflow(
+            function_name=workflow_name,
+            status=status,
+            error=error,
+            args=[],
+            kwargs={},
+        )
+        session.add(workflow)
+
+        failed_steps = 0
+        if status == WorkflowStatus.FAILED:
+            failed_steps = 1
+
+        running_steps = total_steps - completed_steps - failed_steps
+
+        for i in range(completed_steps):
+            step = WorkflowStep(
+                workflow_id=workflow.id,
+                step_id=i + 1,
+                status=StepStatus.SUCCEEDED,
+                function_name=f"dummy_step_{i + 1}",
+                step_type=StepType.COMPUTE,
+                args=[],
+                kwargs={},
+            )
+            session.add(step)
+
+        for i in range(failed_steps):
+            step = WorkflowStep(
+                workflow_id=workflow.id,
+                step_id=completed_steps + i + 1,
+                status=StepStatus.FAILED,
+                function_name=f"dummy_step_{completed_steps + i + 1}",
+                step_type=StepType.COMPUTE,
+                args=[],
+                kwargs={},
+            )
+            session.add(step)
+
+        for i in range(running_steps):
+            step = WorkflowStep(
+                workflow_id=workflow.id,
+                step_id=completed_steps + failed_steps + i + 1,
+                status=StepStatus.RUNNING,
+                function_name=f"dummy_step_{completed_steps + failed_steps + i + 1}",
+                step_type=StepType.COMPUTE,
+                args=[],
+                kwargs={},
+            )
+            session.add(step)
+
+        await session.commit()
+        await session.refresh(workflow)
+        return workflow
+
+
 async def test_list_workflows(client: PlanarTestClient):
     """
     Test that the workflow management router correctly lists registered workflows.
@@ -139,8 +250,8 @@ async def test_list_workflows(client: PlanarTestClient):
     data = response.json()
 
     # Verify that two workflows are returned
-    assert data["total"] == 2
-    assert len(data["items"]) == 2
+    assert data["total"] == 4
+    assert len(data["items"]) == 4
 
     assert data["offset"] == 0
     assert data["limit"] == 10
@@ -182,6 +293,162 @@ async def test_list_workflows(client: PlanarTestClient):
     assert "run_statuses" in file_workflow
 
 
+async def test_list_workflow_runs_no_runs(client: PlanarTestClient):
+    """Test listing runs for a workflow that has not been run."""
+    response = await client.get(
+        "/planar/v1/workflows/test_expense_approval_workflow/runs"
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["total"] == 0
+    assert len(data["items"]) == 0
+
+
+async def test_list_workflow_runs_multiple_runs(
+    client: PlanarTestClient, tmp_db_engine: AsyncEngine
+):
+    """Test listing runs for a workflow with a mix of succeeded and failed runs."""
+    await asyncio.gather(
+        # Run 1: Successful
+        create_test_workflow_run(
+            tmp_db_engine,
+            workflow_name="test_expense_approval_workflow",
+            status=WorkflowStatus.SUCCEEDED,
+            completed_steps=1,
+            total_steps=1,
+        ),
+        create_test_workflow_run(
+            tmp_db_engine,
+            workflow_name="test_expense_approval_workflow",
+            status=WorkflowStatus.SUCCEEDED,
+            completed_steps=1,
+            total_steps=1,
+        ),
+        # Run 3: Failed
+        create_test_workflow_run(
+            tmp_db_engine,
+            workflow_name="test_expense_approval_workflow",
+            status=WorkflowStatus.FAILED,
+            completed_steps=0,
+            total_steps=1,
+            error={"type": "ValueError", "message": "Forced failure for test"},
+        ),
+    )
+
+    # List runs
+    response = await client.get(
+        "/planar/v1/workflows/test_expense_approval_workflow/runs"
+    )
+    assert response.status_code == 200
+    data = response.json()
+
+    assert data["total"] == 3
+    assert len(data["items"]) == 3
+
+    succeeded_runs = [r for r in data["items"] if r["status"] == "succeeded"]
+    failed_runs = [r for r in data["items"] if r["status"] == "failed"]
+
+    assert len(succeeded_runs) == 2
+    assert len(failed_runs) == 1
+
+    # Assert succeeded run details
+    assert succeeded_runs[0]["step_stats"]["completed"] == 1
+    assert succeeded_runs[1]["step_stats"]["completed"] == 1
+    assert succeeded_runs[0]["step_stats"]["failed"] == 0
+    assert succeeded_runs[1]["step_stats"]["failed"] == 0
+    assert succeeded_runs[0]["step_stats"]["running"] == 0
+    assert succeeded_runs[1]["step_stats"]["running"] == 0
+
+    # Assert failed run details
+    assert failed_runs[0]["step_stats"]["completed"] == 0
+    assert failed_runs[0]["step_stats"]["failed"] == 1
+    assert "ValueError" in failed_runs[0]["error"]["type"]
+
+
+async def test_get_workflow_run_succeeded(
+    client: PlanarTestClient, tmp_db_engine: AsyncEngine
+):
+    """Test getting a single succeeded workflow run."""
+    workflow = await create_test_workflow_run(
+        tmp_db_engine,
+        workflow_name="successful_workflow_3_steps",
+        status=WorkflowStatus.SUCCEEDED,
+        completed_steps=3,
+        total_steps=3,
+    )
+
+    run_resp = await client.get(
+        f"/planar/v1/workflows/successful_workflow_3_steps/runs/{workflow.id}"
+    )
+    assert run_resp.status_code == 200
+    run_data = run_resp.json()
+
+    assert run_data["id"] == str(workflow.id)
+    assert run_data["status"] == "succeeded"
+    assert run_data["step_stats"]["completed"] == 3
+    assert run_data["step_stats"]["failed"] == 0
+    assert run_data["step_stats"]["running"] == 0
+    assert run_data["error"] is None
+
+
+async def test_get_workflow_run_failed(
+    client: PlanarTestClient, tmp_db_engine: AsyncEngine
+):
+    """Test getting a single failed workflow run."""
+    workflow = await create_test_workflow_run(
+        tmp_db_engine,
+        workflow_name="failing_workflow_3_steps",
+        status=WorkflowStatus.FAILED,
+        completed_steps=1,
+        total_steps=2,  # 1 succeeded, 1 failed
+        error={
+            "type": "ValueError",
+            "message": "This step is designed to fail",
+        },
+    )
+
+    run_resp = await client.get(
+        f"/planar/v1/workflows/failing_workflow_3_steps/runs/{workflow.id}"
+    )
+    assert run_resp.status_code == 200
+    run_data = run_resp.json()
+
+    assert run_data["id"] == str(workflow.id)
+    assert run_data["status"] == "failed"
+    assert run_data["step_stats"]["completed"] == 1
+    assert run_data["step_stats"]["failed"] == 1
+    assert run_data["step_stats"]["running"] == 0
+    assert run_data["error"] is not None
+    assert "ValueError" in run_data["error"]["type"]
+    assert "This step is designed to fail" in run_data["error"]["message"]
+
+
+async def test_get_workflow_run_pending_with_running_step(
+    client: PlanarTestClient, tmp_db_engine: AsyncEngine
+):
+    """Test getting a pending workflow with completed and running steps."""
+    workflow = await create_test_workflow_run(
+        tmp_db_engine,
+        workflow_name="pending_workflow_with_running_steps",
+        status=WorkflowStatus.PENDING,
+        completed_steps=3,
+        total_steps=4,  # 3 completed, 1 running
+    )
+
+    run_resp = await client.get(
+        f"/planar/v1/workflows/pending_workflow_with_running_steps/runs/{workflow.id}"
+    )
+    assert run_resp.status_code == 200
+    run_data = run_resp.json()
+
+    assert run_data["id"] == str(workflow.id)
+    assert run_data["status"] == "pending"
+    assert run_data["step_stats"]["completed"] == 3
+    assert run_data["step_stats"]["running"] == 1
+    assert run_data["step_stats"]["failed"] == 0
+    assert run_data["error"] is None
+
+
 async def test_start_file_workflow(
     client: PlanarTestClient,
     planar_file: PlanarFile,

planar/routers/workflow.py

@@ -1,14 +1,18 @@
-from datetime import timedelta
+from datetime import datetime, timedelta
+from typing import Any, Dict
 from uuid import UUID
 
 from fastapi import APIRouter, Body, Depends, HTTPException
-from sqlmodel import select
+from sqlalchemy import Select
+from sqlmodel import case, col, func, select
 
 from planar.modeling.orm.query_filter_builder import build_paginated_query
 from planar.object_registry import ObjectRegistry
 from planar.routers.event import create_workflow_event_routes
 from planar.routers.models import (
     SortDirection,
+    StepRunError,
+    StepStats,
     WorkflowDefinition,
     WorkflowList,
     WorkflowRun,
@@ -35,7 +39,6 @@ from planar.workflows.models import (
 from planar.workflows.query import (
     build_effective_status_case,
     calculate_bulk_workflow_duration_stats,
-    calculate_effective_status,
     calculate_workflow_duration_stats,
     get_bulk_workflow_run_statuses,
     get_workflow_run_statuses,
@@ -43,6 +46,56 @@ from planar.workflows.query import (
 from planar.workflows.step_metadata import get_steps_metadata
 
 
+def build_base_workflow_query(
+    workflow_name: str,
+) -> Select[
+    tuple[
+        UUID,  # Workflow.id
+        list[Any] | None,  # Workflow.args
+        Dict[str, Any] | None,  # Workflow.kwargs
+        Any | None,  # Workflow.result
+        Dict[str, Any] | None,  # Workflow.error
+        datetime,  # Workflow.created_at
+        datetime,  # Workflow.updated_at
+        str,  # effective_status_expr
+        int,  # succeeded_step_count
+        int,  # failed_steps_count
+        int,  # running_steps_count
+    ]
+]:
+    effective_status_expr = build_effective_status_case().label("effective_status")
+
+    return (
+        select(  # type: ignore[call-overload]
+            Workflow.id,
+            Workflow.args,
+            Workflow.kwargs,
+            Workflow.result,
+            Workflow.error,
+            Workflow.created_at,
+            Workflow.updated_at,
+            effective_status_expr,
+            func.count(
+                case((col(WorkflowStep.status) == StepStatus.SUCCEEDED, 1))
+            ).label("succeeded_step_count"),
+            func.count(case((col(WorkflowStep.status) == StepStatus.FAILED, 1))).label(
+                "failed_steps_count"
+            ),
+            func.count(case((col(WorkflowStep.status) == StepStatus.RUNNING, 1))).label(
+                "running_steps_count"
+            ),
+        )
+        .select_from(Workflow)
+        .outerjoin(LockedResource, workflow_lock_join_cond())
+        .outerjoin(WorkflowStep, col(Workflow.id) == col(WorkflowStep.workflow_id))
+        .where(Workflow.function_name == workflow_name)
+        .group_by(
+            col(Workflow.id),
+            col(LockedResource.lock_until),
+        )
+    )
+
+
 def create_workflow_router(
     registry: ObjectRegistry,
 ) -> APIRouter:
@@ -219,23 +272,7 @@ def create_workflow_router(
         )
         session = get_session()
 
-        # Build query with virtual status calculation
-        effective_status_expr = build_effective_status_case().label("effective_status")
-        base_query = (
-            select(  # type: ignore[misc]
-                Workflow.id,
-                Workflow.args,
-                Workflow.kwargs,
-                Workflow.result,
-                Workflow.error,
-                Workflow.created_at,
-                Workflow.updated_at,
-                effective_status_expr,
-            )
-            .select_from(Workflow)
-            .outerjoin(LockedResource, workflow_lock_join_cond())
-            .where(Workflow.function_name == workflow_name)
-        )
+        base_query = build_base_workflow_query(workflow_name)
 
         # Prepare filters - can filter on effective status using SQL
         filters = []
@@ -270,6 +307,11 @@ def create_workflow_router(
                 error=row.error,
                 created_at=row.created_at,
                 updated_at=row.updated_at,
+                step_stats=StepStats(
+                    completed=row.succeeded_step_count,
+                    failed=row.failed_steps_count,
+                    running=row.running_steps_count,
+                ),
             )
             for row in results
         ]
@@ -283,31 +325,49 @@ def create_workflow_router(
             WorkflowAction.WORKFLOW_VIEW_DETAILS,
         )
         session = get_session()
-        workflow = (
+
+        base_query = build_base_workflow_query(workflow_name)
+
+        workflow_info = (
             await session.exec(
-                select(Workflow).where(
-                    Workflow.function_name == workflow_name, Workflow.id == run_id
-                )
+                base_query.where(col(Workflow.id) == run_id)  # type: ignore[arg-type]
             )
         ).first()
 
-        if not workflow:
+        if not workflow_info:
             raise HTTPException(
                 status_code=404,
                 detail=f"Workflow run with id {run_id} not found for workflow {workflow_name}",
             )
 
-        effective_status = await calculate_effective_status(session, workflow)
+        (
+            workflow_id,
+            args,
+            kwargs,
+            result,
+            error,
+            created_at,
+            updated_at,
+            effective_status,
+            step_count,
+            failed_steps_count,
+            running_steps_count,
+        ) = workflow_info
 
         return WorkflowRun(
-            id=workflow.id,
+            id=workflow_id,
             status=effective_status,
-            args=workflow.args,
-            kwargs=workflow.kwargs,
-            result=workflow.result,
-            error=workflow.error,
-            created_at=workflow.created_at,
-            updated_at=workflow.updated_at,
+            args=args,
+            kwargs=kwargs,
+            result=result,
+            error=error,
+            created_at=created_at,
+            updated_at=updated_at,
+            step_stats=StepStats(
+                completed=step_count,
+                failed=failed_steps_count,
+                running=running_steps_count,
+            ),
         )
 
     @router.get("/{workflow_name}/runs/{run_id}/steps", response_model=WorkflowStepList)
@@ -377,7 +437,6 @@ def create_workflow_router(
         # Create step info objects with metadata
         items = []
         for step in steps:
-            # Create the base step info object
             step_info = WorkflowStepInfo(
                 step_id=step.step_id,
                 parent_step_id=step.parent_step_id,
@@ -392,7 +451,7 @@ def create_workflow_router(
                 args=step.args,
                 kwargs=step.kwargs,
                 result=step.result,
-                error=step.error,
+                error=StepRunError.model_validate(step.error) if step.error else None,
                 retry_count=step.retry_count,
                 created_at=step.created_at,
                 updated_at=step.updated_at,
@@ -455,7 +514,7 @@ def create_workflow_router(
             args=step.args,
             kwargs=step.kwargs,
             result=step.result,
-            error=step.error,
+            error=StepRunError.model_validate(step.error) if step.error else None,
             retry_count=step.retry_count,
             created_at=step.created_at,
             updated_at=step.updated_at,