astrbot_plugin_imagestudio/backend/routes/node_routes.py

419 行
15 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.cost_guard_service import CostGuardService
from backend.services.cost_service import CostService
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_bootstrap import sync_generation_provider_from_config
from backend.services.model_provider_service import ModelProviderService
from backend.services.node_dependency_context_service import NodeDependencyContextService
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.queue_service import QueueService
from backend.services.workflow_service import (
LOCKED_NODE_STATUSES,
WorkflowService,
is_repeatable_single_image_node,
locked_node_edit_error,
)
from core.audit_service import AuditService
from core.identity import RequestContext
from core.security import require_authenticated, require_task_retry, require_write
from database.db_helper import Database, load_config_payload, load_database_settings
from database.repositories.image_repository import ImageRepository
from database.repositories.job_repository import JobRepository
from database.repositories.material_repository import MaterialRepository
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,
payload: dict[str, Any] | None = None,
service: WorkflowService | None = None,
generation_service: GenerationService | None = None,
) -> dict:
resolved_generation_service = generation_service
if resolved_generation_service is None and service is None:
resolved_generation_service = _create_generation_service()
workflow_service = (
service
or getattr(resolved_generation_service, "workflow_service", None)
or _create_workflow_service()
)
request_overrides = payload or {}
def action() -> dict[str, Any]:
require_task_retry(ctx)
node = workflow_service.get_node(node_id)
if node.status in LOCKED_NODE_STATUSES and not is_repeatable_single_image_node(node):
raise locked_node_edit_error(node)
if node.status not in _RETRYABLE_NODE_STATUSES and not (
node.status in LOCKED_NODE_STATUSES and is_repeatable_single_image_node(node)
):
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"node cannot be retried from its current status",
{
"node_id": node.node_id,
"status": node.status,
"allowed_statuses": sorted(_RETRYABLE_NODE_STATUSES),
},
)
metadata = node.metadata if isinstance(node.metadata, dict) else {}
last_request = metadata.get("last_generate_request")
if not isinstance(last_request, dict) or not last_request:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"node has no previous generation request to retry",
{
"node_id": node.node_id,
"status": node.status,
"field": "metadata.last_generate_request",
},
)
if resolved_generation_service is None:
raise ApiError(
ErrorCode.UNKNOWN_ERROR,
"generation service is unavailable for node retry",
{"node_id": node.node_id},
)
retry_request = _build_retry_generation_request(node.node_id, last_request, request_overrides)
return resolved_generation_service.generate_node(node.node_id, retry_request, ctx)
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)
config_payload = load_config_payload()
sync_generation_provider_from_config(model_provider_service, config_payload)
generation_config = config_payload.get("generation") if isinstance(config_payload.get("generation"), dict) else {}
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,
allow_mock_fallback=False,
),
model_provider_service=model_provider_service,
cost_guard_service=CostGuardService(CostService(database)),
prompt_expansion_service=PromptExpansionService(),
event_bus=event_bus,
default_model_route=str(generation_config.get("default_model") or "").strip() or None,
require_resolved_model_route=True,
material_resolver=MaterialRepository(database),
)
def _bool(value: Any) -> bool:
if isinstance(value, str):
return value.strip().lower() in {"1", "true", "yes", "on"}
return bool(value)
_RETRYABLE_NODE_STATUSES = frozenset({"failed", "cancelled", "skipped"})
_RETRY_DERIVED_REQUEST_FIELDS = frozenset(
{
"cost_guard",
"expanded_negative_prompt",
"expanded_prompt",
"prompt_expansion",
"reference_persistence",
"resolved_model_route",
}
)
def _build_retry_generation_request(
node_id: str,
last_request: dict[str, Any],
overrides: dict[str, Any],
) -> dict[str, Any]:
omitted_references = _ephemeral_reference_count(last_request)
if omitted_references and not _has_reference_override(overrides):
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"the previous generation used inline reference images; provide replacement references before retrying",
{
"node_id": node_id,
"ephemeral_data_urls_omitted": omitted_references,
"required_fields": ["input_images", "image", "selected_draft_image_ids", "stage_inputs"],
},
)
request = {
key: value
for key, value in last_request.items()
if key not in _RETRY_DERIVED_REQUEST_FIELDS and key != "idempotency_key"
}
for key, value in overrides.items():
if key not in _RETRY_DERIVED_REQUEST_FIELDS and key != "idempotency_key":
request[key] = value
previous_metadata = last_request.get("metadata")
override_metadata = overrides.get("metadata")
if isinstance(previous_metadata, dict) or isinstance(override_metadata, dict):
request["metadata"] = {
**(previous_metadata if isinstance(previous_metadata, dict) else {}),
**(override_metadata if isinstance(override_metadata, dict) else {}),
}
request["idempotency_key"] = f"node-retry-{node_id}-{uuid4().hex}"
return request
def _ephemeral_reference_count(request: dict[str, Any]) -> int:
persistence = request.get("reference_persistence")
if not isinstance(persistence, dict):
return 0
try:
return max(int(persistence.get("ephemeral_data_urls_omitted") or 0), 0)
except (TypeError, ValueError):
return 0
def _has_reference_override(payload: dict[str, Any]) -> bool:
for key in ("input_images", "image", "selected_draft_image_ids", "stage_inputs"):
if _has_nonempty_value(payload.get(key)):
return True
metadata = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}
dependency = payload.get("dependency_context") if isinstance(payload.get("dependency_context"), dict) else {}
return any(
_has_nonempty_value(value)
for value in (
metadata.get("selected_draft_image_ids"),
metadata.get("stage_inputs"),
dependency.get("selected_image_ids"),
dependency.get("selected_draft_image_ids"),
dependency.get("stage_inputs"),
dependency.get("material_bindings"),
)
)
def _has_nonempty_value(value: Any) -> bool:
if value is None:
return False
if isinstance(value, str):
return bool(value.strip())
if isinstance(value, (list, tuple, dict, set)):
return bool(value)
return True