feat: add single image mock generation flow

这个提交存在于:
YokiiroBW 2026-07-05 09:28:39 +08:00
父节点 5888e3b4fd
当前提交 f757166e48
共有 5 个文件被更改,包括 361 次插入 和 1 次删除

查看文件

@ -7,13 +7,16 @@ from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.routes.common import handle_request
from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService
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.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
@ -81,12 +84,16 @@ def generate_node(
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": {
@ -191,3 +198,25 @@ def _create_workflow_service() -> WorkflowService:
profile_repository=ProfileRepository(database),
audit_service=AuditService(database),
)
def _create_generation_service() -> GenerationService:
database = Database(load_database_settings())
audit_service = AuditService(database)
workflow_repository = WorkflowRepository(database)
return GenerationService(
workflow_service=WorkflowService(
workflow_repository=workflow_repository,
profile_repository=ProfileRepository(database),
audit_service=audit_service,
),
queue_service=QueueService(
repository=JobRepository(database),
audit_service=audit_service,
),
image_service=ImageService(
image_repository=ImageRepository(database),
workflow_repository=workflow_repository,
audit_service=audit_service,
),
)

查看文件

@ -0,0 +1,94 @@
"""Generation orchestration service."""
from __future__ import annotations
from typing import Any
from backend.services.image_service import ImageService
from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService
from core.identity import RequestContext
from engines.single_flow import SingleFlowEngine
class GenerationService:
def __init__(
self,
workflow_service: WorkflowService,
queue_service: QueueService,
image_service: ImageService,
single_flow_engine: SingleFlowEngine | None = None,
):
self.workflow_service = workflow_service
self.queue_service = queue_service
self.image_service = image_service
self.single_flow_engine = single_flow_engine or SingleFlowEngine()
def generate_node(self, node_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
node = self.workflow_service.get_node(node_id)
workflow = self.workflow_service.get_workflow(node.workflow_id).workflow
task = self.queue_service.create_task(
{
"profile_id": workflow.profile_id,
"workflow_id": workflow.workflow_id,
"node_id": node_id,
"status": "queued",
"model_route": payload.get("model_route") or node.model_route,
"request": payload,
"metadata": {"source": "nodes.generate"},
},
ctx,
)
self.workflow_service.update_node(
node_id,
{
"status": "queued",
"model_route": payload.get("model_route") or node.model_route,
"metadata": {
**node.metadata,
"last_task_id": task.task_id,
"last_generate_request": payload,
},
},
ctx,
)
self.queue_service.update_task(task.task_id, {"status": "running", "progress": 20}, ctx)
running_node = self.workflow_service.update_node(node_id, {"status": "running"}, ctx)
assets = self.single_flow_engine.generate(running_node, task, payload)
images = [
self.image_service.create_image(
{
"profile_id": workflow.profile_id,
"workflow_id": workflow.workflow_id,
"node_id": node_id,
"task_id": task.task_id,
"image_uri": asset.image_uri,
"thumbnail_uri": asset.thumbnail_uri,
"positive_prompt": asset.positive_prompt,
"model_route": asset.model_route,
"seed": asset.seed,
"width": asset.width,
"height": asset.height,
"is_selected": index == 0,
"metadata": asset.metadata,
},
ctx,
)
for index, asset in enumerate(assets)
]
completed_task = self.queue_service.update_task(
task.task_id,
{
"status": "succeeded",
"progress": 100,
"result": {"image_ids": [image.image_id for image in images]},
},
ctx,
)
completed_node = self.workflow_service.update_node(node_id, {"status": "completed"}, ctx)
return {
"task_id": completed_task.task_id,
"task_status": completed_task.status,
"node_status": completed_node.status,
"images": [image.to_dict() for image in images],
}

查看文件

@ -150,6 +150,28 @@ class QueueService:
)
return after
def update_task(self, task_id: str, payload: dict[str, Any], ctx: RequestContext) -> GenerationTask:
before = self.get_job(task_id)
status = payload.get("status")
if status is not None and status not in TASK_STATUSES:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"unsupported task status",
{"field": "status", "allowed": sorted(TASK_STATUSES)},
)
after = self.repository.update(task_id, payload)
if after is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "task not found", {"task_id": task_id})
self.audit_service.record(
ctx=ctx,
action="update_task",
target_type="generation_task",
target_id=task_id,
before_snapshot=before.to_dict(),
after_snapshot=after.to_dict(),
)
return after
def queue_summary(self) -> dict[str, int]:
counts = self.repository.count_by_status()
return {

查看文件

@ -1 +1,92 @@
"""Single image workflow engine placeholder."""
"""Single image workflow mock engine."""
from __future__ import annotations
import base64
from dataclasses import dataclass
from pathlib import Path
from typing import Any
from backend.dto.job_dto import GenerationTask
from backend.dto.workflow_dto import WorkflowNode
from core.storage import VfsStorage
ONE_PIXEL_PNG = base64.b64decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII="
)
@dataclass(frozen=True)
class MockGeneratedAsset:
image_uri: str
thumbnail_uri: str
positive_prompt: str
model_route: str | None
width: int
height: int
seed: int
metadata: dict[str, Any]
class SingleFlowEngine:
def __init__(self, storage: VfsStorage | None = None):
self.storage = storage or VfsStorage()
def generate(self, node: WorkflowNode, task: GenerationTask, request: dict[str, Any]) -> list[MockGeneratedAsset]:
count = _bounded_count(request.get("count", 1))
prompt = _compose_prompt(node.prompt, request.get("prompt_patch"))
model_route = str(request.get("model_route") or node.model_route or "image_low")
width, height = _dimensions(str(request.get("aspect_ratio") or "1:1"))
assets: list[MockGeneratedAsset] = []
for index in range(count):
seed = int(request.get("seed") or 1000 + index)
image_uri = f"storage://images/single/{task.task_id}_{index + 1}.png"
thumbnail_uri = f"storage://thumbnails/single/{task.task_id}_{index + 1}.png"
self._write_png(image_uri)
self._write_png(thumbnail_uri)
assets.append(
MockGeneratedAsset(
image_uri=image_uri,
thumbnail_uri=thumbnail_uri,
positive_prompt=prompt,
model_route=model_route,
width=width,
height=height,
seed=seed,
metadata={
"engine": "single_flow_mock",
"quality": request.get("quality", "low"),
"mock": True,
},
)
)
return assets
def _write_png(self, uri: str) -> None:
path = self.storage.resolve_uri(uri)
Path(path).parent.mkdir(parents=True, exist_ok=True)
Path(path).write_bytes(ONE_PIXEL_PNG)
def _bounded_count(value: Any) -> int:
try:
count = int(value)
except (TypeError, ValueError):
count = 1
return min(max(count, 1), 8)
def _compose_prompt(base_prompt: str | None, prompt_patch: Any) -> str:
parts = [part.strip() for part in [base_prompt, str(prompt_patch or "")] if part and str(part).strip()]
return ", ".join(parts) if parts else "single image mock generation"
def _dimensions(aspect_ratio: str) -> tuple[int, int]:
if aspect_ratio == "3:4":
return 768, 1024
if aspect_ratio == "4:3":
return 1024, 768
if aspect_ratio == "16:9":
return 1280, 720
return 1024, 1024

查看文件

@ -0,0 +1,124 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.node_routes import generate_node
from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService
from backend.services.profile_service import ProfileService
from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.config_service import ConfigService
from core.identity import RequestContext
from core.storage import VfsStorage
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
from database.repositories.job_repository import JobRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
from engines.single_flow import SingleFlowEngine
class SingleFlowGenerationTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
self.config_path.write_text(
f"""
plugin:
name: astrbot_plugin_imagestudio
storage:
images_path: "{(self.root / "images").as_posix()}"
thumbnails_path: "{(self.root / "thumbnails").as_posix()}"
materials_path: "{(self.root / "materials").as_posix()}"
styles_path: "{(self.root / "styles").as_posix()}"
archives_path: "{(self.root / "archives").as_posix()}"
temp_path: "{(self.root / "temp").as_posix()}"
""",
encoding="utf-8",
)
for folder in ("images", "thumbnails", "materials", "styles", "archives", "temp"):
(self.root / folder).mkdir(parents=True, exist_ok=True)
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db")))
)
self.database.initialize()
self.audit_service = AuditService(self.database)
self.profile_repository = ProfileRepository(self.database)
self.workflow_repository = WorkflowRepository(self.database)
self.image_repository = ImageRepository(self.database)
self.job_repository = JobRepository(self.database)
self.profile_service = ProfileService(self.profile_repository, self.audit_service)
self.workflow_service = WorkflowService(
self.workflow_repository,
self.profile_repository,
self.audit_service,
)
self.image_service = ImageService(
self.image_repository,
self.workflow_repository,
self.audit_service,
)
self.queue_service = QueueService(self.job_repository, self.audit_service)
self.config_service = ConfigService(self.config_path)
self.generation_service = GenerationService(
workflow_service=self.workflow_service,
queue_service=self.queue_service,
image_service=self.image_service,
single_flow_engine=SingleFlowEngine(VfsStorage(self.config_service)),
)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
def tearDown(self):
self.tmp.cleanup()
def test_generate_node_creates_task_images_and_vfs_files(self):
profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
workflow = self.workflow_service.create_workflow(
profile.profile_id,
{"workflow_type": "single_image", "display_name": "Single"},
self.ctx,
)
node_id = workflow.nodes[0].node_id
response = generate_node(
self.ctx,
node_id,
{"prompt_patch": "white shirt", "count": 2, "aspect_ratio": "3:4", "model_route": "image_low"},
generation_service=self.generation_service,
)
self.assertTrue(response["ok"])
data = response["data"]
self.assertTrue(data["task_id"].startswith("task_"))
self.assertEqual(data["task_status"], "succeeded")
self.assertEqual(data["node_status"], "completed")
self.assertEqual(len(data["images"]), 2)
self.assertTrue(data["images"][0]["is_selected"])
self.assertFalse(data["images"][1]["is_selected"])
self.assertEqual(data["images"][0]["width"], 768)
self.assertEqual(data["images"][0]["height"], 1024)
task = self.queue_service.get_job(data["task_id"])
self.assertEqual(task.status, "succeeded")
self.assertEqual(task.result["image_ids"], [image["image_id"] for image in data["images"]])
node = self.workflow_service.get_node(node_id)
self.assertEqual(node.status, "completed")
self.assertEqual(node.selected_image_id, data["images"][0]["image_id"])
for image in data["images"]:
self.assertTrue(VfsStorage(self.config_service).ensure_file(image["image_uri"]).exists())
self.assertTrue(VfsStorage(self.config_service).ensure_file(image["thumbnail_uri"]).exists())
if __name__ == "__main__":
unittest.main()