diff --git a/backend/routes/node_routes.py b/backend/routes/node_routes.py index ffdfd71..4c47b22 100644 --- a/backend/routes/node_routes.py +++ b/backend/routes/node_routes.py @@ -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, + ), + ) diff --git a/backend/services/generation_service.py b/backend/services/generation_service.py new file mode 100644 index 0000000..271336a --- /dev/null +++ b/backend/services/generation_service.py @@ -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], + } diff --git a/backend/services/queue_service.py b/backend/services/queue_service.py index e277bfd..56138eb 100644 --- a/backend/services/queue_service.py +++ b/backend/services/queue_service.py @@ -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 { diff --git a/engines/single_flow.py b/engines/single_flow.py index 2a15ef2..85dcd22 100644 --- a/engines/single_flow.py +++ b/engines/single_flow.py @@ -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 diff --git a/tests/test_single_flow_generation.py b/tests/test_single_flow_generation.py new file mode 100644 index 0000000..a954d8f --- /dev/null +++ b/tests/test_single_flow_generation.py @@ -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()