95 行
5.3 KiB
Python
95 行
5.3 KiB
Python
"""Multi-route visual review used by AstrBot chat commands."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import mimetypes
|
|
from concurrent.futures import ThreadPoolExecutor, as_completed
|
|
from typing import Any
|
|
|
|
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 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 engines.vision_provider import VisionRecognitionRequest
|
|
|
|
|
|
class CrossReviewService:
|
|
def __init__(self):
|
|
self.database = Database(load_database_settings())
|
|
self.images = ImageRepository(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]:
|
|
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 {
|
|
"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("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))
|