198 行
6.7 KiB
Python
198 行
6.7 KiB
Python
"""Workflow generation-round route handlers."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
from backend.dto.common import ApiError
|
|
from backend.routes.common import handle_request
|
|
from backend.routes.params import as_bool
|
|
from backend.routes.node_routes import create_generation_service
|
|
from backend.services.media_service import MediaService
|
|
from backend.services.model_provider_runtime import ModelProviderRuntime
|
|
from backend.services.workflow_round_feedback_service import WorkflowRoundFeedbackService
|
|
from backend.services.workflow_round_service import WorkflowRoundService
|
|
from core.astrbot_provider_bridge import astrbot_structured_text_callable
|
|
from core.identity import RequestContext
|
|
from core.security import require_authenticated, require_write
|
|
from database.repositories.workflow_round_repository import WorkflowRoundRepository
|
|
|
|
|
|
def list_node_rounds(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
query: dict[str, Any] | None = None,
|
|
service: WorkflowRoundService | None = None,
|
|
media_service: MediaService | None = None,
|
|
) -> dict:
|
|
round_service = service or _create_round_service()
|
|
signer = media_service or MediaService()
|
|
params = query or {}
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_authenticated(ctx)
|
|
payload = round_service.list_node_rounds(
|
|
node_id,
|
|
include_legacy=as_bool(params.get("include_legacy"), default=True, non_string_truthiness=True),
|
|
ctx=ctx,
|
|
)
|
|
return _serialize_round_collection(payload, signer)
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def create_node_round(
|
|
ctx: RequestContext,
|
|
node_id: str,
|
|
payload: dict[str, Any] | None = None,
|
|
service: WorkflowRoundService | None = None,
|
|
media_service: MediaService | None = None,
|
|
) -> dict:
|
|
round_service = service or _create_round_service()
|
|
signer = media_service or MediaService()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
return _serialize_round_detail(round_service.create_round(node_id, payload or {}, ctx), signer)
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def get_round(
|
|
ctx: RequestContext,
|
|
round_id: str,
|
|
service: WorkflowRoundService | None = None,
|
|
media_service: MediaService | None = None,
|
|
) -> dict:
|
|
round_service = service or _create_round_service()
|
|
signer = media_service or MediaService()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_authenticated(ctx)
|
|
return _serialize_round_detail(round_service.get_round(round_id, ctx).to_dict(), signer)
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def update_round_feedback(
|
|
ctx: RequestContext,
|
|
round_id: str,
|
|
payload: dict[str, Any] | None = None,
|
|
service: WorkflowRoundService | None = None,
|
|
media_service: MediaService | None = None,
|
|
) -> dict:
|
|
round_service = service or _create_round_service()
|
|
signer = media_service or MediaService()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
return _serialize_round_detail(
|
|
round_service.update_feedback(round_id, payload or {}, ctx),
|
|
signer,
|
|
)
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def confirm_round_candidate(
|
|
ctx: RequestContext,
|
|
round_id: str,
|
|
payload: dict[str, Any] | None = None,
|
|
service: WorkflowRoundService | None = None,
|
|
media_service: MediaService | None = None,
|
|
) -> dict:
|
|
round_service = service or _create_round_service()
|
|
signer = media_service or MediaService()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
return _serialize_round_detail(
|
|
round_service.confirm_candidate(round_id, payload or {}, ctx),
|
|
signer,
|
|
)
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def create_next_round(
|
|
ctx: RequestContext,
|
|
round_id: str,
|
|
payload: dict[str, Any] | None = None,
|
|
service: WorkflowRoundService | None = None,
|
|
media_service: MediaService | None = None,
|
|
) -> dict:
|
|
round_service = service or _create_round_service()
|
|
signer = media_service or MediaService()
|
|
|
|
def action() -> dict[str, Any]:
|
|
require_write(ctx)
|
|
return _serialize_round_detail(
|
|
round_service.create_next_round(round_id, payload or {}, ctx),
|
|
signer,
|
|
)
|
|
|
|
return handle_request(ctx, action)
|
|
|
|
|
|
def _create_round_service() -> WorkflowRoundService:
|
|
generation_service = create_generation_service()
|
|
database = generation_service.queue_service.repository.database
|
|
feedback_route = str(
|
|
generation_service.model_assignments.get("prompt_planning") or ""
|
|
).strip()
|
|
feedback_callable = None
|
|
if feedback_route:
|
|
provider_service = generation_service.model_provider_service
|
|
if provider_service is not None:
|
|
feedback_callable = ModelProviderRuntime(provider_service).structured_text_callable(
|
|
feedback_route
|
|
)
|
|
feedback_callable = feedback_callable or astrbot_structured_text_callable(feedback_route)
|
|
return WorkflowRoundService(
|
|
round_repository=WorkflowRoundRepository(database),
|
|
workflow_repository=generation_service.workflow_service.workflow_repository,
|
|
image_repository=generation_service.image_service.image_repository,
|
|
job_repository=generation_service.queue_service.repository,
|
|
audit_service=generation_service.workflow_service.audit_service,
|
|
generation_service=generation_service,
|
|
feedback_service=WorkflowRoundFeedbackService(
|
|
structured_text_callable=feedback_callable,
|
|
model_route=feedback_route,
|
|
),
|
|
)
|
|
|
|
|
|
def _serialize_round_collection(payload: dict[str, Any], media_service: MediaService) -> dict[str, Any]:
|
|
return {
|
|
**payload,
|
|
"items": [
|
|
_serialize_round_detail(item, media_service)
|
|
for item in payload.get("items", [])
|
|
if isinstance(item, dict)
|
|
],
|
|
}
|
|
|
|
|
|
def _serialize_round_detail(payload: dict[str, Any], media_service: MediaService) -> dict[str, Any]:
|
|
candidates: list[dict[str, Any]] = []
|
|
for item in payload.get("candidates", []):
|
|
if not isinstance(item, dict):
|
|
continue
|
|
image = item.get("image") if isinstance(item.get("image"), dict) else None
|
|
if image is not None:
|
|
image = {
|
|
**image,
|
|
"image_url": _signed_url(media_service, image.get("image_uri")),
|
|
"thumbnail_url": _signed_url(media_service, image.get("thumbnail_uri")),
|
|
}
|
|
candidates.append({**item, "image": image})
|
|
return {**payload, "candidates": candidates}
|
|
|
|
|
|
def _signed_url(media_service: MediaService, uri: Any) -> str | None:
|
|
if not isinstance(uri, str) or not uri:
|
|
return None
|
|
try:
|
|
return media_service.sign_media(uri)["url"]
|
|
except ApiError:
|
|
return None
|