From 67f82366aa3131bcd36085ab0343e9f5964f22c3 Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Mon, 6 Jul 2026 03:00:03 +0800 Subject: [PATCH] =?UTF-8?q?S90-S91=20=E8=A7=92=E8=89=B2=E5=B7=A5=E4=BD=9C?= =?UTF-8?q?=E6=B5=81=E6=89=A7=E8=A1=8C=E5=90=8E=E7=AB=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/route_registry.py | 1 + backend/routes/workflow_routes.py | 15 ++ .../services/character_workflow_service.py | 141 ++++++++++++++++++ tests/test_character_workflow_service.py | 104 +++++++++++++ tests/test_route_registry.py | 1 + 5 files changed, 262 insertions(+) create mode 100644 backend/services/character_workflow_service.py create mode 100644 tests/test_character_workflow_service.py diff --git a/backend/route_registry.py b/backend/route_registry.py index 5e38d5d..56e80aa 100644 --- a/backend/route_registry.py +++ b/backend/route_registry.py @@ -41,6 +41,7 @@ ROUTES: tuple[RouteSpec, ...] = ( RouteSpec("POST", "workflows/{workflow_id}/start", "backend.routes.workflow_routes.start_workflow", "write"), RouteSpec("POST", "workflows/{workflow_id}/cancel", "backend.routes.workflow_routes.cancel_workflow", "write"), RouteSpec("POST", "workflows/{workflow_id}/archive", "backend.routes.workflow_routes.archive_workflow", "write"), + RouteSpec("POST", "workflows/{workflow_id}/execute-character", "backend.routes.workflow_routes.execute_character_workflow", "write"), RouteSpec("GET", "workflows/{workflow_id}/nodes", "backend.routes.node_routes.list_workflow_nodes", "read"), RouteSpec("POST", "workflows/{workflow_id}/nodes", "backend.routes.node_routes.create_workflow_node", "write"), RouteSpec("GET", "workflows/{workflow_id}/branches", "backend.routes.branch_routes.list_workflow_branches", "read"), diff --git a/backend/routes/workflow_routes.py b/backend/routes/workflow_routes.py index 3a6e45f..1c5cebb 100644 --- a/backend/routes/workflow_routes.py +++ b/backend/routes/workflow_routes.py @@ -5,6 +5,7 @@ from __future__ import annotations from typing import Any from backend.routes.common import handle_request +from backend.services.character_workflow_service import CharacterWorkflowService from backend.services.event_stream_service import get_default_event_bus from backend.services.workflow_service import WorkflowService from core.audit_service import AuditService @@ -112,6 +113,20 @@ def _set_workflow_status( return handle_request(ctx, action) +def execute_character_workflow( + ctx: RequestContext, + workflow_id: str, + service: CharacterWorkflowService | None = None, +) -> dict: + character_service = service or CharacterWorkflowService(_create_workflow_service()) + + def action() -> dict: + require_write(ctx) + return character_service.execute_workflow(workflow_id, ctx) + + return handle_request(ctx, action) + + def _create_workflow_service() -> WorkflowService: database = Database(load_database_settings()) return WorkflowService( diff --git a/backend/services/character_workflow_service.py b/backend/services/character_workflow_service.py new file mode 100644 index 0000000..0f0ce5b --- /dev/null +++ b/backend/services/character_workflow_service.py @@ -0,0 +1,141 @@ +"""Deterministic execution helpers for character workflows.""" + +from __future__ import annotations + +from typing import Any + +from backend.dto.common import ApiError, ErrorCode +from backend.dto.profile_dto import CharacterProfile +from backend.dto.workflow_dto import ProfileWorkflow, WorkflowNode +from backend.services.workflow_service import WorkflowService +from core.identity import RequestContext + + +CHARACTER_WORKFLOW_TYPES = {"character_fast", "character_gradual"} + + +class CharacterWorkflowService: + def __init__(self, workflow_service: WorkflowService): + self.workflow_service = workflow_service + + def execute_workflow(self, workflow_id: str, ctx: RequestContext) -> dict[str, Any]: + detail = self.workflow_service.get_workflow(workflow_id) + workflow = detail.workflow + if workflow.workflow_type not in CHARACTER_WORKFLOW_TYPES: + raise ApiError( + ErrorCode.VALIDATION_FAILED, + "workflow is not a character workflow", + {"workflow_id": workflow_id, "workflow_type": workflow.workflow_type}, + ) + profile = self.workflow_service.profile_repository.get(workflow.profile_id) + if profile is None: + raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "profile not found", {"profile_id": workflow.profile_id}) + active_nodes = [ + node + for node in sorted(detail.nodes, key=lambda item: item.sort_order) + if node.branch_name == workflow.current_branch + ] + if not active_nodes: + raise ApiError(ErrorCode.VALIDATION_FAILED, "workflow has no executable nodes", {"workflow_id": workflow_id}) + running_workflow = workflow + if workflow.status != "running": + running_workflow = self.workflow_service.update_workflow(workflow_id, {"status": "running"}, ctx) + completed_nodes: list[WorkflowNode] = [] + prompt_context: list[str] = [] + for node in active_nodes: + prompt = _node_prompt(profile, node, running_workflow, prompt_context) + negative_prompt = _negative_prompt(profile, node) + completed = self.workflow_service.update_node( + node.node_id, + { + "status": "completed", + "prompt": prompt, + "negative_prompt": negative_prompt, + "metadata": { + **node.metadata, + "execution": { + "executor": "character_workflow", + "workflow_type": workflow.workflow_type, + "context_prompts": len(prompt_context), + }, + }, + }, + ctx, + ) + completed_nodes.append(completed) + prompt_context.append(prompt) + completed_workflow = self.workflow_service.update_workflow( + workflow_id, + { + "status": "completed", + "current_node_id": completed_nodes[-1].node_id, + "metadata": { + **running_workflow.metadata, + "character_execution": { + "executor": "character_workflow", + "workflow_type": workflow.workflow_type, + "completed_node_ids": [node.node_id for node in completed_nodes], + }, + }, + }, + ctx, + ) + return { + "workflow": completed_workflow.to_dict(), + "nodes": [node.to_dict() for node in completed_nodes], + "completed_node_ids": [node.node_id for node in completed_nodes], + } + + +def _node_prompt( + profile: CharacterProfile, + node: WorkflowNode, + workflow: ProfileWorkflow, + prompt_context: list[str], +) -> str: + parts = [ + profile.name, + profile.base_prompt, + profile.appearance_prompt, + profile.style_prompt, + _step_instruction(workflow.workflow_type, node.node_key), + node.prompt, + ] + if prompt_context: + parts.append(f"consistency reference: {prompt_context[-1]}") + return ", ".join(_unique_text(parts)) + + +def _negative_prompt(profile: CharacterProfile, node: WorkflowNode) -> str: + return ", ".join(_unique_text([profile.negative_prompt, node.negative_prompt, "low quality, blurry"])) + + +def _step_instruction(workflow_type: str, node_key: str) -> str: + fast = { + "fast_profile": "condensed character design brief", + "fast_candidates": "candidate batch, varied composition, keep identity consistent", + "fast_final": "final selected character illustration, production ready", + } + gradual = { + "profile_brief": "core identity and visual anchors", + "headshot": "headshot, face, hair, eyes, expression", + "half_body": "half body, upper outfit, posture and silhouette", + "full_body": "full body, complete outfit and proportions", + "expression_sheet": "expression sheet with reusable emotions", + "pose_sheet": "pose sheet with action variants", + "style_lock": "style consistency lock and final rendering rules", + "final_pack": "final character pack, accepted images and reusable metadata", + } + table = fast if workflow_type == "character_fast" else gradual + return table.get(node_key, node_key.replace("_", " ")) + + +def _unique_text(values: list[Any]) -> list[str]: + result: list[str] = [] + seen: set[str] = set() + for value in values: + text = str(value or "").strip() + if text and text not in seen: + result.append(text) + seen.add(text) + return result diff --git a/tests/test_character_workflow_service.py b/tests/test_character_workflow_service.py new file mode 100644 index 0000000..ee37413 --- /dev/null +++ b/tests/test_character_workflow_service.py @@ -0,0 +1,104 @@ +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +from backend.routes.workflow_routes import execute_character_workflow +from backend.services.character_workflow_service import CharacterWorkflowService +from backend.services.profile_service import ProfileService +from backend.services.workflow_service import WorkflowService +from core.audit_service import AuditService +from core.identity import RequestContext +from database.db_helper import Database, DatabaseSettings, SqliteSettings +from database.repositories.profile_repository import ProfileRepository +from database.repositories.workflow_repository import WorkflowRepository + + +class CharacterWorkflowServiceTests(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.database = Database( + DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db"))) + ) + self.database.initialize() + self.audit_service = AuditService(self.database) + self.profile_repository = ProfileRepository(self.database) + self.workflow_repository = WorkflowRepository(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.character_service = CharacterWorkflowService(self.workflow_service) + self.ctx = RequestContext.from_astrbot( + username="admin", + user_id="user_001", + permissions={"can_write"}, + ) + self.profile = self.profile_service.create_profile( + { + "name": "Nova", + "base_prompt": "mage student", + "appearance_prompt": "silver hair, blue eyes", + "style_prompt": "watercolor", + "negative_prompt": "low quality", + }, + self.ctx, + ) + + def tearDown(self): + self.tmp.cleanup() + + def test_execute_fast_character_workflow_completes_nodes_with_prompts(self): + detail = self.workflow_service.create_workflow( + self.profile.profile_id, + {"workflow_type": "character_fast", "display_name": "Fast"}, + self.ctx, + ) + + result = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx) + + self.assertEqual(result["workflow"]["status"], "completed") + self.assertEqual(len(result["nodes"]), 3) + self.assertTrue(all(node["status"] == "completed" for node in result["nodes"])) + candidate = next(node for node in result["nodes"] if node["node_key"] == "fast_candidates") + self.assertIn("candidate batch", candidate["prompt"]) + self.assertIn("mage student", candidate["prompt"]) + self.assertEqual(candidate["metadata"]["execution"]["workflow_type"], "character_fast") + + def test_execute_gradual_character_workflow_completes_all_template_steps(self): + detail = self.workflow_service.create_workflow( + self.profile.profile_id, + {"workflow_type": "character_gradual", "display_name": "Gradual"}, + self.ctx, + ) + + result = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx) + + self.assertEqual(len(result["completed_node_ids"]), 8) + final_pack = result["nodes"][-1] + self.assertEqual(final_pack["node_key"], "final_pack") + self.assertIn("final character pack", final_pack["prompt"]) + self.assertIn("consistency reference", final_pack["prompt"]) + + def test_execute_character_workflow_route_requires_write_permission(self): + detail = self.workflow_service.create_workflow( + self.profile.profile_id, + {"workflow_type": "character_fast", "display_name": "Fast"}, + self.ctx, + ) + read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001") + + denied = execute_character_workflow(read_only, detail.workflow.workflow_id, self.character_service) + allowed = execute_character_workflow(self.ctx, detail.workflow.workflow_id, self.character_service) + + self.assertFalse(denied["ok"]) + self.assertEqual(denied["error_code"], "FORBIDDEN") + self.assertTrue(allowed["ok"]) + self.assertEqual(allowed["data"]["workflow"]["status"], "completed") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_route_registry.py b/tests/test_route_registry.py index a8cd72f..7ea0192 100644 --- a/tests/test_route_registry.py +++ b/tests/test_route_registry.py @@ -37,6 +37,7 @@ class RouteRegistryTests(unittest.TestCase): self.assertIn(("POST", "workflows/{workflow_id}/start"), keys) self.assertIn(("POST", "workflows/{workflow_id}/cancel"), keys) self.assertIn(("POST", "workflows/{workflow_id}/archive"), keys) + self.assertIn(("POST", "workflows/{workflow_id}/execute-character"), keys) self.assertIn(("GET", "nodes/{node_id}/review"), keys) self.assertIn(("GET", "workflows/{workflow_id}/review"), keys) self.assertIn(("GET", "review/policy"), keys)