From 9902eaa676a5c5b8ea7eb5c48a7fbd19d38e96ef Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Mon, 6 Jul 2026 03:05:28 +0800 Subject: [PATCH] =?UTF-8?q?S92=20=E8=8A=82=E7=82=B9=E4=BE=9D=E8=B5=96?= =?UTF-8?q?=E4=B8=8A=E4=B8=8B=E6=96=87?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/route_registry.py | 1 + backend/routes/node_routes.py | 29 +++++ .../node_dependency_context_service.py | 76 ++++++++++++ tests/test_node_dependency_context_service.py | 111 ++++++++++++++++++ tests/test_route_registry.py | 1 + 5 files changed, 218 insertions(+) create mode 100644 backend/services/node_dependency_context_service.py create mode 100644 tests/test_node_dependency_context_service.py diff --git a/backend/route_registry.py b/backend/route_registry.py index 56e80aa..d46cb04 100644 --- a/backend/route_registry.py +++ b/backend/route_registry.py @@ -49,6 +49,7 @@ ROUTES: tuple[RouteSpec, ...] = ( RouteSpec("POST", "workflows/{workflow_id}/switch-branch", "backend.routes.branch_routes.switch_workflow_branch", "write"), RouteSpec("GET", "workflows/{workflow_id}/history", "backend.routes.history_routes.list_workflow_history", "read"), RouteSpec("GET", "nodes/{node_id}", "backend.routes.node_routes.get_node", "read"), + RouteSpec("GET", "nodes/{node_id}/dependency-context", "backend.routes.node_routes.get_node_dependency_context", "read"), RouteSpec("PUT", "nodes/{node_id}", "backend.routes.node_routes.update_node", "write"), RouteSpec("POST", "nodes/{node_id}/generate", "backend.routes.node_routes.generate_node", "write"), RouteSpec("POST", "nodes/{node_id}/retry", "backend.routes.node_routes.retry_node", "write"), diff --git a/backend/routes/node_routes.py b/backend/routes/node_routes.py index 4c21852..e58a11f 100644 --- a/backend/routes/node_routes.py +++ b/backend/routes/node_routes.py @@ -12,6 +12,7 @@ from backend.services.generation_service import GenerationService from backend.services.image_service import ImageService from backend.services.model_provider_runtime import ModelProviderRuntime from backend.services.model_provider_service import ModelProviderService +from backend.services.node_dependency_context_service import NodeDependencyContextService from backend.services.queue_service import QueueService from backend.services.workflow_service import WorkflowService from core.audit_service import AuditService @@ -68,6 +69,28 @@ def get_node( return handle_request(ctx, action) +def get_node_dependency_context( + ctx: RequestContext, + node_id: str, + query: dict[str, Any] | None = None, + service: NodeDependencyContextService | None = None, + workflow_service: WorkflowService | None = None, + image_service: ImageService | None = None, +) -> dict: + params = query or {} + if service: + context_service = service + else: + resolved_image_service, resolved_workflow_service = _resolve_services(image_service, workflow_service) + context_service = NodeDependencyContextService(resolved_workflow_service, resolved_image_service) + + def action() -> dict[str, Any]: + require_authenticated(ctx) + return context_service.get_context(node_id, include_draft=_bool(params.get("include_draft"))) + + return handle_request(ctx, action) + + def update_node( ctx: RequestContext, node_id: str, @@ -235,3 +258,9 @@ def _create_generation_service() -> GenerationService: model_provider_service=model_provider_service, event_bus=event_bus, ) + + +def _bool(value: Any) -> bool: + if isinstance(value, str): + return value.strip().lower() in {"1", "true", "yes", "on"} + return bool(value) diff --git a/backend/services/node_dependency_context_service.py b/backend/services/node_dependency_context_service.py new file mode 100644 index 0000000..732e88a --- /dev/null +++ b/backend/services/node_dependency_context_service.py @@ -0,0 +1,76 @@ +"""Build dependency context for workflow nodes.""" + +from __future__ import annotations + +from typing import Any + +from backend.dto.common import ApiError, ErrorCode +from backend.services.image_service import ImageService +from backend.services.workflow_service import WorkflowService + + +CONTEXT_STATUSES = {"completed", "selected"} + + +class NodeDependencyContextService: + def __init__( + self, + workflow_service: WorkflowService, + image_service: ImageService | None = None, + ): + self.workflow_service = workflow_service + self.image_service = image_service + + def get_context(self, node_id: str, *, include_draft: bool = False) -> dict[str, Any]: + target = self.workflow_service.get_node(node_id) + detail = self.workflow_service.get_workflow(target.workflow_id) + dependencies = [] + for node in sorted(detail.nodes, key=lambda item: item.sort_order): + if node.branch_name != target.branch_name or node.sort_order >= target.sort_order: + continue + if not include_draft and node.status not in CONTEXT_STATUSES: + continue + dependencies.append(self._node_context(node)) + prompt_parts = [item["prompt"] for item in dependencies if item.get("prompt")] + selected_image_ids = [ + item["selected_image"]["image_id"] + for item in dependencies + if isinstance(item.get("selected_image"), dict) + ] + return { + "workflow_id": target.workflow_id, + "node_id": target.node_id, + "branch_name": target.branch_name, + "dependency_count": len(dependencies), + "dependencies": dependencies, + "prompt_context": ", ".join(prompt_parts), + "selected_image_ids": selected_image_ids, + } + + def _node_context(self, node) -> dict[str, Any]: + selected_image = None + if node.selected_image_id and self.image_service: + try: + image = self.image_service.get_image(node.selected_image_id) + selected_image = { + "image_id": image.image_id, + "image_uri": image.image_uri, + "thumbnail_uri": image.thumbnail_uri, + "model_route": image.model_route, + "metadata": image.metadata, + } + except ApiError as exc: + if exc.error_code != ErrorCode.RESOURCE_NOT_FOUND: + raise + return { + "node_id": node.node_id, + "node_key": node.node_key, + "title": node.title, + "status": node.status, + "sort_order": node.sort_order, + "prompt": node.prompt, + "negative_prompt": node.negative_prompt, + "selected_image_id": node.selected_image_id, + "selected_image": selected_image, + "metadata": node.metadata, + } diff --git a/tests/test_node_dependency_context_service.py b/tests/test_node_dependency_context_service.py new file mode 100644 index 0000000..55276f1 --- /dev/null +++ b/tests/test_node_dependency_context_service.py @@ -0,0 +1,111 @@ +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +from backend.routes.node_routes import get_node_dependency_context +from backend.services.image_service import ImageService +from backend.services.node_dependency_context_service import NodeDependencyContextService +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.image_repository import ImageRepository +from database.repositories.profile_repository import ProfileRepository +from database.repositories.workflow_repository import WorkflowRepository + + +class NodeDependencyContextServiceTests(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.image_repository = ImageRepository(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.context_service = NodeDependencyContextService(self.workflow_service, self.image_service) + self.ctx = RequestContext.from_astrbot( + username="admin", + user_id="user_001", + permissions={"can_write"}, + ) + self.profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) + + def tearDown(self): + self.tmp.cleanup() + + def test_context_includes_completed_predecessor_prompts_and_selected_images(self): + detail = self.workflow_service.create_workflow( + self.profile.profile_id, + {"workflow_type": "character_gradual", "display_name": "Gradual"}, + self.ctx, + ) + first, second, target = detail.nodes[:3] + image = self.image_service.create_image( + { + "node_id": first.node_id, + "image_uri": "storage://images/headshot.png", + "thumbnail_uri": "storage://thumbnails/headshot.png", + "is_selected": True, + "metadata": {"kind": "headshot"}, + }, + self.ctx, + ) + self.workflow_service.update_node( + first.node_id, + {"status": "completed", "prompt": "headshot, silver hair"}, + self.ctx, + ) + self.workflow_service.update_node( + second.node_id, + {"status": "completed", "prompt": "half body, white blouse"}, + self.ctx, + ) + + context = self.context_service.get_context(target.node_id) + + self.assertEqual(context["dependency_count"], 2) + self.assertEqual(context["selected_image_ids"], [image.image_id]) + self.assertIn("headshot, silver hair", context["prompt_context"]) + self.assertEqual(context["dependencies"][0]["selected_image"]["image_uri"], "storage://images/headshot.png") + self.assertNotIn(str(self.tmp.name), str(context)) + + def test_dependency_context_route_requires_authentication(self): + detail = self.workflow_service.create_workflow( + self.profile.profile_id, + {"workflow_type": "character_fast", "display_name": "Fast"}, + self.ctx, + ) + + allowed = get_node_dependency_context( + self.ctx, + detail.nodes[1].node_id, + {}, + self.context_service, + ) + anonymous = get_node_dependency_context( + RequestContext(), + detail.nodes[1].node_id, + {}, + self.context_service, + ) + + self.assertTrue(allowed["ok"]) + self.assertFalse(anonymous["ok"]) + self.assertEqual(anonymous["error_code"], "UNAUTHORIZED") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_route_registry.py b/tests/test_route_registry.py index 7ea0192..5b4ae04 100644 --- a/tests/test_route_registry.py +++ b/tests/test_route_registry.py @@ -39,6 +39,7 @@ class RouteRegistryTests(unittest.TestCase): 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", "nodes/{node_id}/dependency-context"), keys) self.assertIn(("GET", "workflows/{workflow_id}/review"), keys) self.assertIn(("GET", "review/policy"), keys) self.assertIn(("POST", "review/policy/validate"), keys)