feat: add lightweight review flow

这个提交存在于:
YokiiroBW 2026-07-05 09:46:59 +08:00
父节点 a5c075ec74
当前提交 31c4b753d2
共有 4 个文件被更改,包括 263 次插入 和 1 次删除

查看文件

@ -0,0 +1,57 @@
"""Review route handlers."""
from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.review_service import ReviewService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.identity import RequestContext
from core.security import require_authenticated
from database.db_helper import Database, load_database_settings
from database.repositories.image_repository import ImageRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
def review_node(
ctx: RequestContext,
node_id: str,
service: ReviewService | None = None,
) -> dict:
review_service = service or _create_review_service()
def action() -> dict[str, Any]:
require_authenticated(ctx)
return review_service.review_node(node_id)
return handle_request(ctx, action)
def review_workflow(
ctx: RequestContext,
workflow_id: str,
service: ReviewService | None = None,
) -> dict:
review_service = service or _create_review_service()
def action() -> dict[str, Any]:
require_authenticated(ctx)
return review_service.review_workflow(workflow_id)
return handle_request(ctx, action)
def _create_review_service() -> ReviewService:
database = Database(load_database_settings())
workflow_service = WorkflowService(
workflow_repository=WorkflowRepository(database),
profile_repository=ProfileRepository(database),
audit_service=AuditService(database),
)
return ReviewService(
workflow_service=workflow_service,
image_repository=ImageRepository(database),
)

查看文件

@ -0,0 +1,31 @@
"""Review service for workflow and node readiness checks."""
from __future__ import annotations
from typing import Any
from backend.services.workflow_service import WorkflowService
from database.repositories.image_repository import ImageRepository
from engines.review_flow import ReviewFlowEngine
class ReviewService:
def __init__(
self,
workflow_service: WorkflowService,
image_repository: ImageRepository,
review_engine: ReviewFlowEngine | None = None,
):
self.workflow_service = workflow_service
self.image_repository = image_repository
self.review_engine = review_engine or ReviewFlowEngine()
def review_node(self, node_id: str) -> dict[str, Any]:
node = self.workflow_service.get_node(node_id)
images = self.image_repository.list_by_node(node_id, include_archived=True)
return self.review_engine.review_node(node, images)
def review_workflow(self, workflow_id: str) -> dict[str, Any]:
detail = self.workflow_service.get_workflow(workflow_id)
node_results = [self.review_node(node.node_id) for node in detail.nodes]
return self.review_engine.review_workflow(detail.workflow, detail.nodes, node_results)

查看文件

@ -1 +1,65 @@
"""Review and stability-check workflow placeholder."""
"""Lightweight workflow review checks."""
from __future__ import annotations
from typing import Any
from backend.dto.image_dto import GenerationImage
from backend.dto.workflow_dto import ProfileWorkflow, WorkflowNode
class ReviewFlowEngine:
def review_node(self, node: WorkflowNode, images: list[GenerationImage]) -> dict[str, Any]:
warnings: list[dict[str, Any]] = []
errors: list[dict[str, Any]] = []
if not images:
warnings.append({"code": "NO_IMAGES", "message": "node has no generated images"})
if node.status in {"completed", "selected"} and not node.selected_image_id:
errors.append({"code": "MISSING_SELECTED_IMAGE", "message": "completed node has no selected image"})
if node.selected_image_id and node.selected_image_id not in {image.image_id for image in images}:
errors.append({"code": "SELECTED_IMAGE_NOT_FOUND", "message": "selected image is not in node images"})
if any(image.image_id == node.selected_image_id and image.is_archived for image in images):
errors.append({"code": "SELECTED_IMAGE_ARCHIVED", "message": "selected image is archived"})
return {
"target_type": "node",
"target_id": node.node_id,
"passed": not errors,
"warnings": warnings,
"errors": errors,
"summary": {
"image_count": len(images),
"selected_image_id": node.selected_image_id,
"node_status": node.status,
},
}
def review_workflow(
self,
workflow: ProfileWorkflow,
nodes: list[WorkflowNode],
node_results: list[dict[str, Any]],
) -> dict[str, Any]:
errors = [error for result in node_results for error in result["errors"]]
warnings = [warning for result in node_results for warning in result["warnings"]]
incomplete = [node.node_id for node in nodes if node.status not in {"completed", "selected", "skipped"}]
if incomplete:
warnings.append(
{
"code": "INCOMPLETE_NODES",
"message": "workflow has nodes that are not finished",
"node_ids": incomplete,
}
)
return {
"target_type": "workflow",
"target_id": workflow.workflow_id,
"passed": not errors,
"warnings": warnings,
"errors": errors,
"summary": {
"workflow_type": workflow.workflow_type,
"node_count": len(nodes),
"incomplete_count": len(incomplete),
},
"nodes": node_results,
}

110
tests/test_review_service.py 普通文件
查看文件

@ -0,0 +1,110 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.review_routes import review_node, review_workflow
from backend.services.history_service import HistoryService
from backend.services.image_service import ImageService
from backend.services.profile_service import ProfileService
from backend.services.review_service import ReviewService
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 ReviewServiceTests(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.history_service = HistoryService(
self.workflow_repository,
self.workflow_service,
self.image_service,
self.audit_service,
)
self.review_service = ReviewService(self.workflow_service, self.image_repository)
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)
self.workflow = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_fast", "display_name": "Fast"},
self.ctx,
)
def tearDown(self):
self.tmp.cleanup()
def test_review_node_warns_without_images_and_errors_without_selected_image(self):
node = self.workflow.nodes[0]
empty = self.review_service.review_node(node.node_id)
self.assertTrue(empty["passed"])
self.assertEqual(empty["warnings"][0]["code"], "NO_IMAGES")
self.workflow_service.update_node(node.node_id, {"status": "completed"}, self.ctx)
missing_selection = self.review_service.review_node(node.node_id)
self.assertFalse(missing_selection["passed"])
self.assertEqual(missing_selection["errors"][0]["code"], "MISSING_SELECTED_IMAGE")
def test_review_passes_after_image_adoption(self):
node = self.workflow.nodes[1]
image = self.image_service.create_image(
{
"node_id": node.node_id,
"image_uri": "storage://images/fast.png",
"positive_prompt": "fast character",
},
self.ctx,
)
self.history_service.adopt_node_image(node.node_id, {"image_id": image.image_id}, self.ctx)
result = self.review_service.review_node(node.node_id)
self.assertTrue(result["passed"])
self.assertEqual(result["summary"]["selected_image_id"], image.image_id)
def test_review_routes_require_authentication(self):
node = self.workflow.nodes[0]
response = review_node(self.ctx, node.node_id, self.review_service)
self.assertTrue(response["ok"])
workflow_response = review_workflow(self.ctx, self.workflow.workflow.workflow_id, self.review_service)
self.assertTrue(workflow_response["ok"])
self.assertEqual(workflow_response["data"]["summary"]["node_count"], 3)
anonymous = RequestContext()
denied = review_node(anonymous, node.node_id, self.review_service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()