267 行
9.3 KiB
Python
267 行
9.3 KiB
Python
"""Workflow node route handlers."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
from uuid import uuid4
|
|
|
|
from backend.dto.common import ApiError, ErrorCode
|
|
from backend.routes.common import handle_request
|
|
from backend.services.event_stream_service import get_default_event_bus
|
|
from backend.services.generation_service import GenerationService
|
|
from backend.services.image_service import ImageService
|
|
from backend.services.model_provider_runtime import ModelProviderRuntime
|
|
from backend.services.model_provider_service import ModelProviderService
|
|
from backend.services.node_dependency_context_service import NodeDependencyContextService
|
|
from backend.services.queue_service import QueueService
|
|
from backend.services.workflow_service import WorkflowService
|
|
from core.audit_service import AuditService
|
|
from core.identity import RequestContext
|
|
from core.security import require_authenticated, require_write
|
|
from database.db_helper import Database, load_database_settings
|
|
from database.repositories.image_repository import ImageRepository
|
|
from database.repositories.job_repository import JobRepository
|
|
from database.repositories.model_provider_repository import ModelProviderRepository
|
|
from database.repositories.profile_repository import ProfileRepository
|
|
from database.repositories.workflow_repository import WorkflowRepository
|
|
from engines.single_flow import SingleFlowEngine
|
|
|
|
|
|
def list_workflow_nodes(
|
|
ctx: RequestContext,
|
|
workflow_id: str,
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> list[dict[str, Any]]:
|
|
require_authenticated(ctx)
|
|
return [node.to_dict() for node in workflow_service.list_nodes(workflow_id)]
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def create_workflow_node(
|
|
ctx: RequestContext,
|
|
workflow_id: str,
|
|
payload: dict[str, Any],
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
return workflow_service.create_node(workflow_id, payload, ctx).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def get_node(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_authenticated(ctx)
|
|
return workflow_service.get_node(node_id).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def get_node_dependency_context(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
query: dict[str, Any] | None = None,
|
|
service: NodeDependencyContextService | None = None,
|
|
workflow_service: WorkflowService | None = None,
|
|
image_service: ImageService | None = None,
|
|
) -> dict:
|
|
params = query or {}
|
|
if service:
|
|
context_service = service
|
|
else:
|
|
resolved_image_service, resolved_workflow_service = _resolve_services(image_service, workflow_service)
|
|
context_service = NodeDependencyContextService(resolved_workflow_service, resolved_image_service)
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_authenticated(ctx)
|
|
return context_service.get_context(node_id, include_draft=_bool(params.get("include_draft")))
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def update_node(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
payload: dict[str, Any],
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
return workflow_service.update_node(node_id, payload, ctx).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def generate_node(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
payload: dict[str, Any] | None = None,
|
|
service: WorkflowService | None = None,
|
|
generation_service: GenerationService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
resolved_generation_service = generation_service or (None if service else _create_generation_service())
|
|
request_payload = payload or {}
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
if resolved_generation_service:
|
|
return resolved_generation_service.generate_node(node_id, request_payload, ctx)
|
|
update_payload: dict[str, Any] = {
|
|
"status": "queued",
|
|
"metadata": {
|
|
"last_generate_request": request_payload,
|
|
"queue_placeholder": True,
|
|
},
|
|
}
|
|
if "model_route" in request_payload:
|
|
update_payload["model_route"] = request_payload["model_route"]
|
|
node = workflow_service.update_node(node_id, update_payload, ctx)
|
|
return {
|
|
"task_id": None,
|
|
"request_id": f"genreq_{uuid4().hex}",
|
|
"node_status": node.status,
|
|
"queue_placeholder": True,
|
|
}
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def retry_node(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
node = workflow_service.update_node(node_id, {"status": "queued"}, ctx)
|
|
return {"node_id": node.node_id, "node_status": node.status, "queue_placeholder": True}
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def select_node_image(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
payload: dict[str, Any],
|
|
image_service: ImageService | None = None,
|
|
workflow_service: WorkflowService | None = None,
|
|
) -> dict:
|
|
selected_image_service, selected_workflow_service = _resolve_services(image_service, workflow_service)
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
selected_workflow_service.get_node(node_id)
|
|
image_id = str(payload.get("image_id") or "").strip()
|
|
if not image_id:
|
|
raise ApiError(ErrorCode.VALIDATION_FAILED, "image_id is required", {"field": "image_id"})
|
|
image = selected_image_service.get_image(image_id)
|
|
if image.node_id != node_id:
|
|
raise ApiError(
|
|
ErrorCode.VALIDATION_FAILED,
|
|
"image does not belong to this node",
|
|
{"image_id": image_id, "node_id": node_id},
|
|
)
|
|
return selected_image_service.select_image(image_id, ctx).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def mark_node_completed(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
service: WorkflowService | None = None,
|
|
) -> dict:
|
|
workflow_service = service or _create_workflow_service()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
return workflow_service.update_node(node_id, {"status": "completed"}, ctx).to_dict()
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def _resolve_services(
|
|
image_service: ImageService | None,
|
|
workflow_service: WorkflowService | None,
|
|
) -> tuple[ImageService, WorkflowService]:
|
|
if image_service and workflow_service:
|
|
return image_service, workflow_service
|
|
database = Database(load_database_settings())
|
|
audit_service = AuditService(database)
|
|
event_bus = get_default_event_bus()
|
|
resolved_workflow_service = workflow_service or WorkflowService(
|
|
workflow_repository=WorkflowRepository(database),
|
|
profile_repository=ProfileRepository(database),
|
|
audit_service=audit_service,
|
|
event_bus=event_bus,
|
|
)
|
|
resolved_image_service = image_service or ImageService(
|
|
image_repository=ImageRepository(database),
|
|
workflow_repository=WorkflowRepository(database),
|
|
audit_service=audit_service,
|
|
)
|
|
return resolved_image_service, resolved_workflow_service
|
|
|
|
|
|
def _create_workflow_service() -> WorkflowService:
|
|
database = Database(load_database_settings())
|
|
return WorkflowService(
|
|
workflow_repository=WorkflowRepository(database),
|
|
profile_repository=ProfileRepository(database),
|
|
audit_service=AuditService(database),
|
|
event_bus=get_default_event_bus(),
|
|
)
|
|
|
|
|
|
def _create_generation_service() -> GenerationService:
|
|
database = Database(load_database_settings())
|
|
audit_service = AuditService(database)
|
|
workflow_repository = WorkflowRepository(database)
|
|
event_bus = get_default_event_bus()
|
|
model_provider_service = ModelProviderService(ModelProviderRepository(database))
|
|
model_provider_runtime = ModelProviderRuntime(model_provider_service)
|
|
return GenerationService(
|
|
workflow_service=WorkflowService(
|
|
workflow_repository=workflow_repository,
|
|
profile_repository=ProfileRepository(database),
|
|
audit_service=audit_service,
|
|
event_bus=event_bus,
|
|
),
|
|
queue_service=QueueService(
|
|
repository=JobRepository(database),
|
|
audit_service=audit_service,
|
|
event_bus=event_bus,
|
|
),
|
|
image_service=ImageService(
|
|
image_repository=ImageRepository(database),
|
|
workflow_repository=workflow_repository,
|
|
audit_service=audit_service,
|
|
),
|
|
single_flow_engine=SingleFlowEngine(image_provider_factory=model_provider_runtime.image_provider_for_route),
|
|
model_provider_service=model_provider_service,
|
|
event_bus=event_bus,
|
|
)
|
|
|
|
|
|
def _bool(value: Any) -> bool:
|
|
if isinstance(value, str):
|
|
return value.strip().lower() in {"1", "true", "yes", "on"}
|
|
return bool(value)
|