astrbot_plugin_imagestudio/backend/services/cross_review_service.py

127 行
6.6 KiB
Python

"""Multi-route VLM visual-quality review used by AstrBot chat commands.
Generation-based cross review is planned separately by
``GenerationCrossReviewPlanner`` and must use image-generation routes.
"""
from __future__ import annotations
import base64
import mimetypes
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.services.model_provider_bootstrap import sync_vision_provider_from_config
from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService
from backend.services.workflow_progression_service import ensure_character_gradual_node_access
from core.storage import VfsStorage
from database.db_helper import Database, load_config_payload, load_database_settings
from database.repositories.image_repository import ImageRepository
from database.repositories.model_provider_repository import ModelProviderRepository
from database.repositories.workflow_repository import WorkflowRepository
from engines.vision_provider import VisionRecognitionRequest
class CrossReviewService:
def __init__(self):
self.database = Database(load_database_settings())
self.images = ImageRepository(self.database)
self.workflows = WorkflowRepository(self.database)
self.storage = VfsStorage()
self.config = load_config_payload()
provider_service = ModelProviderService(ModelProviderRepository(self.database))
sync_vision_provider_from_config(provider_service, self.config)
self.runtime = ModelProviderRuntime(provider_service)
def review_node(self, node_id: str) -> dict[str, Any]:
node = self.workflows.get_node(node_id)
if node is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "node not found", {"node_id": node_id})
workflow = self.workflows.get_workflow(node.workflow_id)
if workflow is None:
raise ApiError(
ErrorCode.RESOURCE_NOT_FOUND,
"workflow not found",
{"workflow_id": node.workflow_id},
)
ensure_character_gradual_node_access(
workflow,
self.workflows.list_nodes(node.workflow_id, branch_name=node.branch_name),
node,
operation="review",
)
images = self.images.list_by_node(node_id, include_archived=False)
selected = next((item for item in images if item.is_selected), None) or (images[0] if images else None)
if selected is None:
return {"routes": [], "reviews": [], "consensus": "节点没有可审核图片", "disagreements": []}
image_data = self._data_url(selected.image_uri)
routes = self._routes()
reviews: list[dict[str, Any]] = []
with ThreadPoolExecutor(max_workers=min(len(routes), 4) or 1) as executor:
futures = {executor.submit(self._review_route, route, image_data, selected.image_id): route for route in routes}
for future in as_completed(futures):
route = futures[future]
try:
reviews.append(future.result())
except Exception as exc:
reviews.append({"route": route, "status": "failed", "error": str(exc)})
successful = [item for item in reviews if item.get("status") == "succeeded"]
defects = sorted({tag for item in successful for tag in item.get("defects", [])})
return {
"review_kind": "visual_quality",
"image_id": selected.image_id,
"routes": routes,
"reviews": reviews,
"consensus": "、".join(defects) if defects else ("未发现明确缺陷" if successful else "没有模型完成审核"),
"disagreements": _disagreements(successful),
"average_confidence": round(sum(float(item.get("confidence") or 0) for item in successful) / len(successful), 3) if successful else 0,
}
def _review_route(self, route: str, image_data: str, image_id: str) -> dict[str, Any]:
provider = self.runtime.vision_provider_for_route({"route_name": route, "modality": "cross_review", "image_id": image_id})
if provider is None:
raise ValueError("审核模型路由不可用或凭据缺失")
instruction = (
"Independently inspect this generated character image. Check identity consistency, anatomy, hands, face, "
"clothing structure, material, composition, text, watermark and rendering artifacts. Return JSON using the "
"required fields. Put defect labels in tags, detailed verdict in description, recommended correction in prompt, "
"and confidence from 0 to 1. Do not agree with another reviewer because no other verdict is provided."
)
result = provider.recognize_material(VisionRecognitionRequest(
display_name=f"cross review {image_id}", image_uri=image_data,
metadata={"recognition_instruction": instruction},
))
return {
"route": route, "provider_id": result.provider_id, "model": result.model, "status": "succeeded",
"defects": result.tags, "confidence": result.confidence, "verdict": result.description,
"recommendation": result.prompt, "negative_prompt": result.negative_prompt,
}
def _routes(self) -> list[str]:
assignments = self.config.get("model_assignments") if isinstance(self.config.get("model_assignments"), dict) else {}
configured = assignments.get("visual_review_routes")
if not isinstance(configured, list) or not configured:
configured = assignments.get("cross_review_routes")
routes = [str(item).strip() for item in configured] if isinstance(configured, list) else []
routes.extend([str(assignments.get("cross_review_primary") or "").strip(), str(assignments.get("cross_review_secondary") or "").strip()])
return list(dict.fromkeys(item for item in routes if item))
def _data_url(self, uri: str) -> str:
path = self.storage.ensure_file(uri)
mime = mimetypes.guess_type(path.name)[0] or "image/png"
return f"data:{mime};base64,{base64.b64encode(path.read_bytes()).decode('ascii')}"
def _disagreements(reviews: list[dict[str, Any]]) -> list[str]:
if len(reviews) < 2:
return []
tag_sets = [set(item.get("defects", [])) for item in reviews]
union = set().union(*tag_sets)
return sorted(tag for tag in union if not all(tag in tags for tags in tag_sets))
# Clear name for new call sites; keep CrossReviewService as the compatibility
# symbol used by existing chat commands and tests.
VisualQualityReviewService = CrossReviewService