astrbot_plugin_imagestudio/backend/routes/round_routes.py

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.services.service_registry 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