"""Style-only multi-image extraction and prompt-only transfer validation. The existing advanced-material service remains the compatibility boundary for single-image imports. This coordinator adds a child-task graph only when the server-confirmed material category is ``风格``/``style``: * one independent VLM task per source image; * one multi-image consensus VLM task after the source barrier; * one compatibility validation attempt containing three independent image generation cases with deliberately unrelated characters and scenes. No validation request carries a source image. The source set is used only by the recognition and consensus stages. """ from __future__ import annotations import json import re from copy import deepcopy from dataclasses import replace from typing import Any from uuid import uuid4 from backend.dto.common import ApiError, ErrorCode from backend.dto.material_dto import Material from backend.dto.workflow_dto import WorkflowNode from backend.services.material_normalization_service import MaterialNormalizationError from backend.services.material_service import ( _normalize_upload_content_type, _normalize_upload_filename, _normalize_upload_metadata, _normalize_upload_size, _recognition_metadata, _storage_image_data_url, _vision_provider_error, ) from backend.services.worker_service import WorkerTaskUpdate from core.identity import RequestContext from engines.image_provider import ImageProviderError from engines.vision_provider import VisionProviderError, VisionRecognitionRequest MIN_STYLE_SOURCES = 2 MAX_STYLE_SOURCES = 8 STYLE_SOURCE_TERMINAL = {"succeeded", "failed", "excluded", "cancelled"} STYLE_SOURCE_EXECUTABLE = {"queued", "running"} STYLE_CONSENSUS_EXECUTABLE = {"queued", "running"} STYLE_CASE_EXECUTABLE = {"queued", "running"} STYLE_ATTEMPT_BLOCKING = {"queued", "running", "validation_partial_failed", "awaiting_review"} STYLE_SET_KIND = "advanced_style_set" STYLE_VALIDATION_SEEDS = (240719, 240720, 240721) # The provider still returns a free-form review, but fidelity is deliberately # recomputed on the server from a stable set of dimensions. This keeps scores # comparable across providers and prevents a visually attractive image from # receiving a high score while missing the actual line, face or shading grammar. STYLE_REVIEW_SCHEMA_VERSION = 2 STYLE_REVIEW_DIMENSIONS: tuple[str, ...] = ( "face_structure", "eye_design", "hair_rendering", "linework", "palette_global", "palette_local", "shading", "highlights", "anatomy_scale", "texture_detail", "background_rendering", ) STYLE_REVIEW_DIMENSION_ALIASES: dict[str, tuple[str, ...]] = { "face_structure": ("face", "face_proportions", "facial_structure", "chin", "mouth_nose"), "eye_design": ("eyes", "eye_geometry", "iris", "iris_construction", "eyelashes"), "hair_rendering": ("hair", "hair_strands", "hair_mass", "strand_grouping"), "linework": ("lines", "line_art", "lineart", "outline", "line_topology"), "palette_global": ("palette", "color", "colour", "global_palette", "value_range", "saturation"), "palette_local": ("local_color", "local_colour", "local_contrast", "color_separation", "colour_separation"), "shading": ("shadow", "shadows", "shadow_rendering", "cel_shading"), "highlights": ("highlight", "highlight_shape", "specular"), "anatomy_scale": ("anatomy", "body_ratio", "head_to_body_ratio", "proportions"), "texture_detail": ("texture", "detail", "detail_density", "rendering_detail"), "background_rendering": ("background", "scene_rendering", "environment", "optical_effects"), } STYLE_REVIEW_WEIGHTS: dict[str, dict[str, float]] = { "portrait": { "face_structure": 0.20, "eye_design": 0.18, "hair_rendering": 0.11, "linework": 0.16, "palette_global": 0.08, "palette_local": 0.07, "shading": 0.09, "highlights": 0.06, "anatomy_scale": 0.02, "texture_detail": 0.03, "background_rendering": 0.00, }, "fullbody": { "face_structure": 0.08, "eye_design": 0.06, "hair_rendering": 0.09, "linework": 0.19, "palette_global": 0.10, "palette_local": 0.09, "shading": 0.13, "highlights": 0.05, "anatomy_scale": 0.14, "texture_detail": 0.06, "background_rendering": 0.01, }, "novel_scene": { "face_structure": 0.08, "eye_design": 0.06, "hair_rendering": 0.08, "linework": 0.18, "palette_global": 0.12, "palette_local": 0.09, "shading": 0.12, "highlights": 0.06, "anatomy_scale": 0.07, "texture_detail": 0.07, "background_rendering": 0.07, }, } DEFAULT_VALIDATION_CASES: tuple[dict[str, Any], ...] = ( { "case_key": "portrait", "content_prompt": ( "a new fictional heroine with short silver hair and teal eyes wearing a simple navy jacket, " "head-and-shoulders portrait against a softly lit neutral studio background, with a distinct identity and wardrobe" ), "aspect_ratio": "1:1", }, { "case_key": "fullbody", "content_prompt": ( "the same new fictional heroine with short silver hair and teal eyes wearing the same simple navy jacket, " "complete head-to-toe full body standing pose in a clean daylight studio, with a distinct identity and wardrobe" ), "aspect_ratio": "2:3", }, { "case_key": "novel_scene", "content_prompt": ( "the same new fictional heroine with short silver hair, teal eyes and navy jacket walking through a breezy rooftop garden at dawn, " "wide environmental view with clear depth and a scene unrelated to the source samples" ), "aspect_ratio": "16:9", }, ) class AdvancedStyleSetService: """Coordinate style-set work while reusing the advanced-material runtime.""" def __init__(self, owner: Any): self.owner = owner self.repository = owner.repository self.material_repository = owner.material_repository self.queue_service = owner.queue_service self.audit_service = owner.audit_service self.storage = owner.storage self.normalization_service = owner.normalization_service self.model_provider_runtime = owner.model_provider_runtime self.single_flow_engine = owner.single_flow_engine @staticmethod def is_style_set(record: Any) -> bool: metadata = record.metadata if isinstance(getattr(record, "metadata", None), dict) else {} return str(metadata.get("workflow_kind") or "").strip() == STYLE_SET_KIND def upload(self, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]: category_id = _optional_text(payload.get("category_id")) category = self.material_repository.get_category(category_id) if category_id else None if category is None: raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "material category not found", {"category_id": category_id}) if not _is_style_category(category): raise ApiError( ErrorCode.VALIDATION_FAILED, "multi-image advanced imports are only available for the style category", {"category_id": category_id, "category_name": category.name, "required_category": "风格"}, ) images = payload.get("images") if not isinstance(images, list) or not MIN_STYLE_SOURCES <= len(images) <= MAX_STYLE_SOURCES: raise ApiError( ErrorCode.VALIDATION_FAILED, "advanced style sets require between 2 and 8 source images", {"field": "images", "min_items": MIN_STYLE_SOURCES, "max_items": MAX_STYLE_SOURCES}, ) if any(not isinstance(item, dict) for item in images): raise ApiError(ErrorCode.VALIDATION_FAILED, "every style source must be an object", {"field": "images"}) import_id = f"advimp_{uuid4().hex}" display_name = str(payload.get("display_name") or "进阶画风组").strip() or "进阶画风组" upload_metadata = _normalize_upload_metadata(payload.get("metadata")) recognition_route = _optional_text(payload.get("recognition_model_route")) or self.owner._recognition_route() generation_route = _optional_text(payload.get("generation_model_route")) or self.owner._generation_route() persisted: list[dict[str, Any]] = [] try: for index, image in enumerate(images): source_id = f"advsrc_{uuid4().hex}" filename = _normalize_upload_filename(image.get("filename")) uri, detected_type, size_bytes, original_filename = self.owner._persist_source( import_id=f"{import_id}/{source_id}", image_data_url=str(image.get("image_data_url") or "").strip(), image_uri=str(image.get("image_uri") or "").strip(), filename=filename, declared_content_type=_normalize_upload_content_type(image.get("content_type")), declared_size=_normalize_upload_size(image), ) persisted.append( { "source_id": source_id, "uri": uri, "filename": original_filename, "content_type": detected_type, "size_bytes": size_bytes, "sort_order": index, "is_primary": index == 0, "upload_source": str(image.get("upload_source") or "file"), } ) record, sources = self.repository.create_style_import_with_sources( { "import_id": import_id, "category_id": category_id, "display_name": display_name, "source_image_uri": persisted[0]["uri"], "source_thumbnail_uri": persisted[0]["uri"], "status": "style_source_recognition_queued", "recognition_model_route": recognition_route, "prompt_revision": 0, "created_by": ctx.actor_id, "metadata": { "workflow_kind": STYLE_SET_KIND, "style_source_count": len(persisted), "generation_model_route": generation_route, "governance_context": {"user_id": ctx.actor_id, "entrypoint": "web"}, "material_tier": "advanced_pending", "upload": {**upload_metadata, "storage_root": "advanced_materials", "source": "style_set"}, }, }, [ { "source_id": item["source_id"], "import_id": import_id, "sort_order": item["sort_order"], "is_primary": item["is_primary"], "source_image_uri": item["uri"], "source_thumbnail_uri": item["uri"], "status": "queued", "recognition_model_route": recognition_route, "metadata": { "upload": { "filename": item["filename"], "content_type": item["content_type"], "size_bytes": item["size_bytes"], "source": item["upload_source"], }, "retry_count": 0, }, } for item in persisted ], ) except Exception: for item in persisted: self.owner._remove_uri(str(item.get("uri") or "")) raise tasks = [] for source in sources: try: tasks.append(self._queue_source(record, source, ctx)) except Exception as exc: self.repository.update_style_source( source.source_id, {"status": "failed", "error": _safe_failure(exc)}, ) # If task creation itself failed for every source there will be no # worker callback to advance the parent record. Running the barrier # here is harmless while any source is still queued and prevents a # permanently busy import when all queue writes failed. self._after_source_terminal(import_id, ctx) current = self.owner._require_import(import_id) self.audit_service.record( ctx=ctx, action="upload_advanced_style_set", target_type="advanced_material_import", target_id=import_id, after_snapshot=current.to_dict(), metadata={"source_count": len(sources), "task_ids": [task.task_id for task in tasks]}, ) return { "import": current.to_dict(), "sources": [item.to_dict() for item in self.repository.list_style_sources(import_id)], "tasks": [task.to_dict() for task in tasks], "queued": bool(tasks), } def detail(self, record: Any) -> dict[str, Any]: record = self.reconcile_missing_tasks(record) sources = self.repository.list_style_sources(record.import_id) consensuses = self.repository.list_style_consensus_runs(record.import_id) attempts = self.repository.list_attempts(record.import_id) cases = ( self.repository.list_style_validation_cases(record.current_attempt_id) if record.current_attempt_id else [] ) return { "style_set": True, "sources": [item.to_dict() for item in sources], "consensus": consensuses[0].to_dict() if consensuses else None, "consensus_history": [item.to_dict() for item in consensuses], "validation_cases": [item.to_dict() for item in cases], "attempts": [item.to_dict() for item in attempts], } def reconcile_missing_tasks(self, record: Any) -> Any: """Turn dangling active child rows into explicit retryable failures. Queue retention and manual queue deletion legitimately remove terminal task rows. If a split write left a child in queued/running state, the task foreign key becomes NULL and the style workbench used to remain busy forever. Reconciliation is deliberately side-effect free with respect to providers: it never enqueues new work. """ import_id = record.import_id missing_sources: list[str] = [] for source in self.repository.list_style_sources(import_id): if source.status not in STYLE_SOURCE_EXECUTABLE or not self._task_missing(source.task_id): continue failure = _missing_queue_task_failure(source.task_id, "style_source_recognition") self.repository.update_style_source( source.source_id, {"status": "failed", "task_id": None, "error": failure}, ) missing_sources.append(source.source_id) missing_consensus: list[str] = [] for consensus in self.repository.list_style_consensus_runs(import_id): if consensus.status not in STYLE_CONSENSUS_EXECUTABLE or not self._task_missing(consensus.task_id): continue failure = _missing_queue_task_failure(consensus.task_id, "style_consensus") self.repository.update_style_consensus_run( consensus.consensus_id, {"status": "failed", "task_id": None, "error": failure}, expected_statuses=STYLE_CONSENSUS_EXECUTABLE, ) missing_consensus.append(consensus.consensus_id) affected_attempts: set[str] = set() for attempt in self.repository.list_attempts(import_id): for case in self.repository.list_style_validation_cases(attempt.attempt_id): if case.status not in STYLE_CASE_EXECUTABLE or not self._task_missing(case.task_id): continue failure = _missing_queue_task_failure(case.task_id, "style_validation_generation") self.repository.update_style_validation_case( case.case_id, {"status": "failed", "task_id": None, "error": failure}, expected_statuses=STYLE_CASE_EXECUTABLE, ) affected_attempts.add(attempt.attempt_id) for attempt_id in affected_attempts: self.repository.finalize_style_validation_batch_if_ready(import_id, attempt_id) if missing_sources: record = self.repository.update_import( import_id, { "status": "style_source_review_required", "error": { "error_type": "queue_task_missing", "stage": "style_source_recognition", "source_ids": missing_sources, }, }, ) or record elif missing_consensus: record = self.repository.update_import( import_id, { "status": "style_consensus_failed", "error": { "error_type": "queue_task_missing", "stage": "style_consensus", "consensus_ids": missing_consensus, }, }, ) or record elif affected_attempts: record = self.repository.get_import(import_id) or record return record def _task_missing(self, task_id: str | None) -> bool: if not str(task_id or "").strip(): return True try: self.queue_service.get_job(str(task_id)) except ApiError: return True return False def retry_source(self, import_id: str, source_id: str, ctx: RequestContext) -> dict[str, Any]: record = self.owner._require_import(import_id) self._require_style_set(record) self._require_sources_editable(record) source = self._require_source(import_id, source_id) if source.status not in {"failed", "excluded", "cancelled"}: raise ApiError( ErrorCode.VALIDATION_FAILED, "style source is not retryable", {"source_id": source_id, "status": source.status}, ) retry_count = int(source.metadata.get("retry_count") or 0) + 1 # Failed source tasks persist the route that was active when the style # set was uploaded. A configuration repair must take effect when the # user explicitly retries; otherwise an obsolete route such as # ``material_vlm`` is frozen forever and every retry repeats the same # pre-provider failure. Keep normal first-run tasks immutable, but # refresh both the child and parent route at this explicit retry # boundary so the later consensus stage uses the same repaired chain. refreshed_route = self.owner._recognition_route() retry_route = ( refreshed_route or source.recognition_model_route or record.recognition_model_route ) if retry_route and retry_route != record.recognition_model_route: record = self.repository.update_import( import_id, {"recognition_model_route": retry_route}, ) or record source = self.repository.update_style_source( source_id, { "status": "queued", "task_id": None, "error": None, "excluded_at": None, "recognition_model_route": retry_route, "metadata": {**source.metadata, "retry_count": retry_count}, }, ) try: task = self._queue_source(record, source, ctx) except Exception as exc: self.repository.update_style_source( source_id, {"status": "failed", "task_id": None, "error": _safe_failure(exc)}, ) self._after_source_terminal(import_id, ctx) raise return {"import": self.owner._require_import(import_id).to_dict(), "source": source.to_dict(), "task": task.to_dict()} def exclude_source( self, import_id: str, source_id: str, excluded: bool, ctx: RequestContext, ) -> dict[str, Any]: record = self.owner._require_import(import_id) self._require_style_set(record) self._require_sources_editable(record) source = self._require_source(import_id, source_id) if excluded: if source.is_primary: raise ApiError( ErrorCode.VALIDATION_FAILED, "the primary style source cannot be excluded; choose another primary before upload", {"source_id": source_id}, ) remaining = [item for item in self.repository.list_style_sources(import_id) if item.source_id != source_id and item.status != "excluded"] if len(remaining) < MIN_STYLE_SOURCES: raise ApiError( ErrorCode.VALIDATION_FAILED, "at least two style sources must remain active", {"min_sources": MIN_STYLE_SOURCES}, ) if source.task_id: try: self.queue_service.cancel_job(source.task_id, ctx, reason="style source excluded") except ApiError: pass updated = self.repository.update_style_source( source_id, { "status": "excluded", "metadata": {**source.metadata, "status_before_exclusion": source.status}, }, ) else: restored = str(source.metadata.get("status_before_exclusion") or "").strip() if source.recognition_result: restored = "succeeded" elif restored not in {"failed", "cancelled"}: restored = "failed" updated = self.repository.update_style_source( source_id, {"status": restored, "excluded_at": None}, ) self.repository.update_import(import_id, {"status": "style_source_review_required"}) return {"import": self.owner._require_import(import_id).to_dict(), "source": updated.to_dict()} def create_consensus( self, import_id: str, payload: dict[str, Any], ctx: RequestContext, ) -> dict[str, Any]: record = self.owner._require_import(import_id) self._require_style_set(record) if record.status in {"accepted", "archived", "cancelled"}: raise ApiError( ErrorCode.VALIDATION_FAILED, "advanced style set no longer accepts consensus work", {"import_id": import_id, "status": record.status}, ) if record.current_attempt_id: current_attempt = self.repository.get_attempt(record.current_attempt_id) if current_attempt is not None and current_attempt.status in STYLE_ATTEMPT_BLOCKING: raise ApiError( ErrorCode.VALIDATION_FAILED, "finish or retry the current style validation batch before creating another consensus", { "import_id": import_id, "attempt_id": current_attempt.attempt_id, "attempt_status": current_attempt.status, }, ) latest = self.repository.get_latest_style_consensus_run(import_id) if latest is not None and latest.status in STYLE_CONSENSUS_EXECUTABLE: task = None if latest.task_id: try: task = self.queue_service.get_job(latest.task_id) except ApiError: task = None if task is not None and task.status in {"queued", "running"}: return {"import": record.to_dict(), "consensus": latest.to_dict(), "task": task.to_dict()} # Repair a split write (child row says active but its queue record # is absent/terminal) before attempting the next revision. The # partial unique index otherwise rejects every future retry. stale_error = { "error_type": "missing_or_terminal_consensus_task", "task_id": latest.task_id, "task_status": getattr(task, "status", None), } latest = self.repository.update_style_consensus_run( latest.consensus_id, {"status": "failed", "error": stale_error}, expected_statuses=STYLE_CONSENSUS_EXECUTABLE, ) or latest sources = self.repository.list_style_sources(import_id, include_excluded=False) active = [item for item in sources if item.status not in STYLE_SOURCE_TERMINAL] succeeded = [item for item in sources if item.status == "succeeded"] if active: raise ApiError( ErrorCode.VALIDATION_FAILED, "style source recognition is still running", {"active_source_ids": [item.source_id for item in active]}, ) if len(succeeded) < MIN_STYLE_SOURCES: raise ApiError( ErrorCode.VALIDATION_FAILED, "at least two successfully recognized style sources are required", {"succeeded": len(succeeded), "min_sources": MIN_STYLE_SOURCES}, ) revision = int(latest.revision if latest else 0) + 1 legacy_adjustment = _optional_text(payload.get("adjustment_text")) style_adjustment = _optional_text(payload.get("style_adjustment_text")) or legacy_adjustment validation_instruction = _optional_text(payload.get("validation_instruction")) reuse_cases = payload.get("reuse_validation_cases") if not validation_instruction else [] style_adjustment_plan = _style_adjustment_plan(payload.get("style_adjustment_plan"), style_adjustment) consensus = self.repository.create_style_consensus_run( { "consensus_id": f"advconsensus_{uuid4().hex}", "import_id": import_id, "revision": revision, "status": "queued", "model_route": record.recognition_model_route or self.owner._recognition_route(), "source_ids": [item.source_id for item in succeeded], "metadata": { "adjustment_text": style_adjustment, "style_adjustment_text": style_adjustment, "validation_instruction": validation_instruction, "reuse_validation_cases": reuse_cases if isinstance(reuse_cases, list) else [], "style_adjustment_plan": style_adjustment_plan, "comparison_attempt_id": _optional_text(payload.get("comparison_attempt_id")), "comparison_consensus_id": _optional_text(payload.get("comparison_consensus_id")), "comparison_source_ids": _string_list(payload.get("comparison_source_ids"))[:3], "requested_by": ctx.actor_id, }, } ) try: task = self.queue_service.create_task( { "task_type": "advanced_style_consensus", "status": "queued", "model_route": consensus.model_route, "idempotency_key": f"advanced-style-consensus:{import_id}:{revision}", "request": {"import_id": import_id, "consensus_id": consensus.consensus_id, "operation": "style_consensus"}, "metadata": { "source": "advanced_material", "advanced_material_import_id": import_id, "advanced_style_consensus_id": consensus.consensus_id, "stage": "style_consensus", "task_summary": f"进阶画风/{record.display_name}/第{revision}版交叉分析", }, }, ctx, ) consensus = self.repository.update_style_consensus_run(consensus.consensus_id, {"task_id": task.task_id}) or consensus self.repository.update_import( import_id, { "status": "style_consensus_queued", "error": None, "metadata": {**record.metadata, "current_consensus_id": consensus.consensus_id}, }, ) except Exception as exc: failure = _safe_failure(exc) self.repository.update_style_consensus_run( consensus.consensus_id, {"status": "failed", "error": failure}, expected_statuses=STYLE_CONSENSUS_EXECUTABLE, ) self.repository.update_import( import_id, { "status": "style_consensus_failed", "error": failure, "metadata": {**record.metadata, "current_consensus_id": consensus.consensus_id}, }, ) raise return {"import": self.owner._require_import(import_id).to_dict(), "consensus": consensus.to_dict(), "task": task.to_dict()} def retry_validation_case(self, import_id: str, case_id: str, ctx: RequestContext) -> dict[str, Any]: record = self.owner._require_import(import_id) self._require_style_set(record) case = self._require_case(import_id, case_id) if case.status not in {"failed", "cancelled"}: raise ApiError(ErrorCode.VALIDATION_FAILED, "validation case is not retryable", {"case_id": case_id, "status": case.status}) retry_count = int(case.metadata.get("retry_count") or 0) + 1 case = self.repository.update_style_validation_case( case_id, { "status": "queued", "task_id": None, "error": None, "metadata": {**case.metadata, "retry_count": retry_count}, }, ) try: task = self._queue_validation_case(record, case, ctx) except Exception as exc: self.repository.update_style_validation_case( case_id, {"status": "failed", "task_id": None, "error": _safe_failure(exc)}, expected_statuses={"queued"}, ) self.repository.finalize_style_validation_batch_if_ready(import_id, case.attempt_id) raise attempt = self.repository.update_attempt(case.attempt_id, {"status": "running", "error": None}) self.repository.update_import(import_id, {"status": "validating", "error": None}) return {"import": self.owner._require_import(import_id).to_dict(), "attempt": attempt.to_dict(), "case": case.to_dict(), "task": task.to_dict()} def ensure_validation( self, record: Any, payload: dict[str, Any], ctx: RequestContext, ) -> dict[str, Any]: """Return the active batch or create it from the latest consensus.""" self._require_style_set(record) if record.current_attempt_id: attempt = self.repository.get_attempt(record.current_attempt_id) cases = self.repository.list_style_validation_cases(record.current_attempt_id) if attempt is not None and cases and attempt.status in { "queued", "running", "validation_partial_failed", "awaiting_review", }: tasks = [] for item in cases: if not item.task_id: continue try: tasks.append(self.queue_service.get_job(item.task_id).to_dict()) except ApiError: # The persisted case state remains authoritative. A # missing old queue row must not make the detail/retry # endpoint unusable after queue retention cleanup. continue return { "import": record.to_dict(), "attempt": attempt.to_dict(), "validation_cases": [item.to_dict() for item in cases], "tasks": tasks, } adjustment = _optional_text(payload.get("adjustment_text")) if adjustment: return self.create_consensus( record.import_id, {"adjustment_text": adjustment}, ctx, ) consensus = self.repository.get_latest_style_consensus_run(record.import_id) if consensus is None or consensus.status != "succeeded": return self.create_consensus(record.import_id, {}, ctx) attempt, cases, tasks = self._queue_validation_batch(record, consensus, ctx) return { "import": self.owner._require_import(record.import_id).to_dict(), "attempt": attempt.to_dict(), "validation_cases": [item.to_dict() for item in cases], "tasks": [item.to_dict() for item in tasks], } def execute_task(self, task: Any, ctx: RequestContext) -> WorkerTaskUpdate: if task.task_type == "advanced_style_source_recognition": return self._execute_source(task, ctx) if task.task_type == "advanced_style_consensus": return self._execute_consensus(task, ctx) if task.task_type == "advanced_style_validation_generation": return self._execute_validation_case(task, ctx) raise RuntimeError(f"unsupported advanced style task type: {task.task_type}") def handle_failure(self, task: Any, exc: Exception, ctx: RequestContext) -> None: import_id = _optional_text(task.metadata.get("advanced_material_import_id")) if not import_id: return record = self.repository.get_import(import_id) if record is None or record.status in {"accepted", "archived", "cancelled"}: return failure = _safe_failure(exc) handled = False if task.task_type == "advanced_style_source_recognition": source_id = _optional_text(task.metadata.get("advanced_style_source_id")) if source_id: source = self.repository.get_style_source(source_id) if source is not None and source.import_id == import_id and source.task_id == task.task_id: changed = self.repository.update_style_source_if_status( source_id, STYLE_SOURCE_EXECUTABLE, {"status": "failed", "error": failure}, ) if changed is not None: handled = True self._after_source_terminal(import_id, ctx) elif task.task_type == "advanced_style_consensus": consensus_id = _optional_text(task.metadata.get("advanced_style_consensus_id")) if consensus_id: consensus = self.repository.get_style_consensus_run(consensus_id) if consensus is not None and consensus.import_id == import_id and consensus.task_id == task.task_id: changed = self.repository.update_style_consensus_run( consensus_id, {"status": "failed", "error": failure}, expected_statuses=STYLE_CONSENSUS_EXECUTABLE, ) if changed is not None: handled = True self.repository.update_import(import_id, {"status": "style_consensus_failed", "error": failure}) elif task.task_type == "advanced_style_validation_generation": case_id = _optional_text(task.metadata.get("advanced_style_validation_case_id")) if case_id: case = self.repository.get_style_validation_case(case_id) if case is not None and case.import_id == import_id and case.task_id == task.task_id: changed = self.repository.update_style_validation_case( case_id, {"status": "failed", "error": failure}, expected_statuses=STYLE_CASE_EXECUTABLE, ) if changed is not None: handled = True self.repository.finalize_style_validation_batch_if_ready(import_id, case.attempt_id) if not handled: # A stale worker/result must not overwrite a later retry, # exclusion, cancellation or already-published success. return self.audit_service.record( ctx=ctx, action="advanced_style_task_failed", target_type="advanced_material_import", target_id=import_id, metadata={"task_id": task.task_id, "task_type": task.task_type, "failure": failure}, ) def reject_and_rebuild( self, record: Any, attempt: Any, payload: dict[str, Any], ctx: RequestContext, ) -> dict[str, Any]: cases = self.repository.list_style_validation_cases(attempt.attempt_id) if record.current_attempt_id != attempt.attempt_id or record.status != "awaiting_review" or attempt.status != "awaiting_review": raise ApiError(ErrorCode.VALIDATION_FAILED, "only the current completed style validation batch can be rejected") legacy_adjustment = _optional_text(payload.get("adjustment_text")) style_adjustment = _optional_text(payload.get("style_adjustment_text")) validation_instruction = _optional_text(payload.get("validation_instruction")) if legacy_adjustment and not style_adjustment and not validation_instruction: # Backward compatibility: the legacy single text box did not say # whether feedback targeted style or validation content. Apply it # to both paths so it can no longer be silently discarded. style_adjustment = legacy_adjustment validation_instruction = legacy_adjustment if not style_adjustment and not validation_instruction: raise ApiError( ErrorCode.VALIDATION_FAILED, "style_adjustment_text or validation_instruction is required", {"fields": ["style_adjustment_text", "validation_instruction"]}, ) style_adjustment_plan = _parse_style_adjustment(style_adjustment) comparison_consensus_id = _optional_text(attempt.metadata.get("style_consensus_id")) comparison_consensus = ( self.repository.get_style_consensus_run(comparison_consensus_id) if comparison_consensus_id else None ) comparison_source_ids = ( _string_list(comparison_consensus.result.get("representative_source_ids"))[:3] if comparison_consensus is not None else [] ) adjustment_summary = _review_adjustment_summary(style_adjustment, validation_instruction) self.repository.update_attempt( attempt.attempt_id, { "status": "rejected", "decision": "rejected", "adjustment_text": adjustment_summary, "decision_notes": _optional_text(payload.get("decision_notes")) or adjustment_summary, "fidelity_score": _optional_score(payload.get("fidelity_score")), "metadata": { **attempt.metadata, "style_adjustment_text": style_adjustment, "validation_instruction": validation_instruction, "style_adjustment_plan": style_adjustment_plan, "comparison_consensus_id": comparison_consensus_id, "comparison_source_ids": comparison_source_ids, "rejected_by": ctx.actor_id, }, }, ) self.repository.update_import(record.import_id, {"status": "adjustment_required"}) reuse_cases = [] if validation_instruction else [ {"case_key": item.case_key, "content_prompt": item.content_prompt, "metadata": item.metadata} for item in cases ] return self.create_consensus( record.import_id, { "style_adjustment_text": style_adjustment, "validation_instruction": validation_instruction, "reuse_validation_cases": reuse_cases, "style_adjustment_plan": style_adjustment_plan, "comparison_attempt_id": attempt.attempt_id, "comparison_consensus_id": comparison_consensus_id, "comparison_source_ids": comparison_source_ids, }, ctx, ) def accept( self, record: Any, attempt: Any, payload: dict[str, Any], ctx: RequestContext, ) -> dict[str, Any]: if record.accepted_material_id: material = self.repository.get_material(record.accepted_material_id) if material is not None: return {"import": record.to_dict(), "attempt": attempt.to_dict(), "material": material.to_dict()} cases = self.repository.list_style_validation_cases(attempt.attempt_id) if ( record.current_attempt_id != attempt.attempt_id or record.status != "awaiting_review" or attempt.status != "awaiting_review" or len(cases) != 3 or any(item.status != "succeeded" or not item.validation_image_uri for item in cases) ): raise ApiError(ErrorCode.VALIDATION_FAILED, "all three current style validation cases must succeed before sealing") consensus = self.repository.get_latest_style_consensus_run(record.import_id) if consensus is None or consensus.status != "succeeded": raise ApiError(ErrorCode.VALIDATION_FAILED, "the current style consensus is not complete") expected_consensus = str(attempt.metadata.get("style_consensus_id") or "") if expected_consensus and expected_consensus != consensus.consensus_id: raise ApiError(ErrorCode.VALIDATION_FAILED, "validation batch does not belong to the latest style consensus") sources = [item for item in self.repository.list_style_sources(record.import_id) if item.status == "succeeded"] source_by_id = {item.source_id: item for item in sources} result = consensus.result if isinstance(consensus.result, dict) else {} representative_ids = [item for item in _string_list(result.get("representative_source_ids")) if item in source_by_id] if not representative_ids: representative_ids = [item.source_id for item in sources[:3]] primary = next((item for item in sources if item.is_primary), sources[0]) capsules = result.get("generation_capsules") if isinstance(result.get("generation_capsules"), dict) else {} profile = result.get("normalized_asset_profile") if isinstance(result.get("normalized_asset_profile"), dict) else {} fidelity_score = _optional_score(payload.get("fidelity_score")) decision_notes = _optional_text(payload.get("decision_notes")) attempt = self.repository.update_attempt( attempt.attempt_id, {"fidelity_score": fidelity_score, "decision_notes": decision_notes}, ) or attempt validation_payload = [item.to_dict() for item in cases] metadata = { "library_kind": "advanced", "priority_class": "advanced_verified", "material_priority": 100, "workflow_kind": STYLE_SET_KIND, "style_set": { "source_ids": [item.source_id for item in sources], "source_image_uris": [item.source_image_uri for item in sources], "representative_source_ids": representative_ids[:3], "reference_source_uris": [source_by_id[item].source_image_uri for item in representative_ids[:3]], "consensus_id": consensus.consensus_id, "consensus_revision": consensus.revision, "validation_cases": validation_payload, }, "verification": { "import_id": record.import_id, "attempt_id": attempt.attempt_id, "attempt_number": attempt.attempt_number, "fidelity_score": fidelity_score, "decision_notes": decision_notes, "validation_image_uri": cases[0].validation_image_uri, "prompt_revision": consensus.revision, }, "recognition": result.get("recognition") or {}, "raw_analysis": result.get("raw_analysis") or {}, "normalized_asset_profile": {**profile, "category": "style", "role": "style", "body_slots": ["global_style"], "confirmed": True}, "generation_capsules": capsules, "content_leakage_exclusions": result.get("content_leakage_exclusions") or [], "confirmed": True, } material = self.repository.accept_attempt( record.import_id, attempt.attempt_id, { "material_id": f"advmat_{uuid4().hex}", "category_id": record.category_id, "display_name": record.display_name, "source_image_uri": primary.source_image_uri, "source_thumbnail_uri": primary.source_thumbnail_uri, "validation_image_uri": cases[0].validation_image_uri, "validation_thumbnail_uri": cases[0].validation_thumbnail_uri, "prompt": consensus.prompt or record.recognition_prompt, "negative_prompt": consensus.negative_prompt or record.recognition_negative_prompt, "tags": consensus.tags, "priority": 100, "status": "active", "capsule": capsules, "decision_notes": decision_notes, "metadata": metadata, }, ) return { "import": self.owner._require_import(record.import_id).to_dict(), "attempt": self.owner._require_attempt(record.import_id, attempt.attempt_id).to_dict(), "material": material.to_dict(), } def cancel(self, record: Any, ctx: RequestContext) -> None: task_ids: set[str] = set() for source in self.repository.list_style_sources(record.import_id): if source.task_id and source.status in STYLE_SOURCE_EXECUTABLE: task_ids.add(source.task_id) self.repository.update_style_source(source.source_id, {"status": "cancelled"}) for consensus in self.repository.list_style_consensus_runs(record.import_id): if consensus.task_id and consensus.status in STYLE_CONSENSUS_EXECUTABLE: task_ids.add(consensus.task_id) self.repository.update_style_consensus_run(consensus.consensus_id, {"status": "cancelled"}) for attempt in self.repository.list_attempts(record.import_id): for case in self.repository.list_style_validation_cases(attempt.attempt_id): if case.task_id and case.status in STYLE_CASE_EXECUTABLE: task_ids.add(case.task_id) self.repository.update_style_validation_case(case.case_id, {"status": "cancelled"}) for task_id in task_ids: try: self.queue_service.cancel_job(task_id, ctx, reason="advanced style set cancelled") except ApiError: pass def _queue_source(self, record: Any, source: Any, ctx: RequestContext): retry_count = int(source.metadata.get("retry_count") or 0) task = self.queue_service.create_task( { "task_type": "advanced_style_source_recognition", "status": "queued", "model_route": source.recognition_model_route or record.recognition_model_route or self.owner._recognition_route(), "idempotency_key": f"advanced-style-source:{source.source_id}:{retry_count}", "request": {"import_id": record.import_id, "source_id": source.source_id, "operation": "recognize_style_source"}, "metadata": { "source": "advanced_material", "advanced_material_import_id": record.import_id, "advanced_style_source_id": source.source_id, "stage": "style_source_recognition", "task_summary": f"进阶画风/{record.display_name}/样本{source.sort_order + 1}", }, }, ctx, ) self.repository.update_style_source(source.source_id, {"status": "queued", "task_id": task.task_id, "error": None}) self.repository.update_import(record.import_id, {"status": "style_source_recognition_queued", "error": None}) return task def _execute_source(self, task: Any, ctx: RequestContext) -> WorkerTaskUpdate: import_id = _required_task_value(task, "advanced_material_import_id") source_id = _required_task_value(task, "advanced_style_source_id") record = self.owner._require_import(import_id) self._require_style_set(record) source = self._require_source(import_id, source_id) if source.status == "succeeded": return WorkerTaskUpdate(result={"source_id": source_id, "status": "succeeded"}) if source.status not in STYLE_SOURCE_EXECUTABLE or source.task_id != task.task_id: raise RuntimeError("style source recognition no longer owns the source") source = self.repository.update_style_source_if_status(source_id, {"queued", "running"}, {"status": "running", "error": None}) if source is None: raise RuntimeError("style source recognition could not claim the source") self.repository.update_import(import_id, {"status": "recognizing_style_sources"}) route_name = source.recognition_model_route or record.recognition_model_route or self.owner._recognition_route() provider = self.model_provider_runtime.vision_provider_for_route( {"route_name": route_name, "modality": "vision_recognition", "material_id": source_id, "image_uri": source.source_image_uri} ) if provider is None: raise ApiError(ErrorCode.MODEL_CAPABILITY_UNCONFIRMED, "advanced style vision route is unavailable", {"route_name": route_name}) image_data_url, content_type, size_bytes = _storage_image_data_url(source.source_image_uri, {}, self.storage) request = VisionRecognitionRequest( display_name=f"{record.display_name} / sample {source.sort_order + 1}", image_uri=image_data_url, metadata={ "recognition_instruction": _single_style_instruction(), "style_set": True, "source_id": source_id, "vision_input": {"source_uri": source.source_image_uri, "content_type": content_type, "size_bytes": size_bytes}, }, ) try: recognition = provider.recognize_material(request) except VisionProviderError as exc: raise ApiError(ErrorCode.GENERATION_FAILED, "advanced style source recognition failed", _vision_provider_error(exc)) from None structures = self.normalization_service.normalize_recognition( recognition.structured_data, prompt=recognition.prompt, negative_prompt=recognition.negative_prompt, tags=recognition.tags, confidence=recognition.confidence, provider_id=recognition.provider_id, model=recognition.model, route_name=route_name, category_hint="风格", ) structures = _force_style_structures(structures) result = {"recognition": _recognition_metadata(recognition, route_name=route_name), **structures} updated = self.repository.update_style_source_if_status( source_id, {"running"}, { "status": "succeeded", "provider_id": recognition.provider_id, "provider_model": recognition.model, "recognition_prompt": recognition.prompt, "recognition_negative_prompt": recognition.negative_prompt, "recognition_tags": recognition.tags, "recognition_result": result, "error": None, }, ) if updated is None: raise RuntimeError("style source result arrived after exclusion or cancellation") self._after_source_terminal(import_id, ctx) return WorkerTaskUpdate(result={"import_id": import_id, "source_id": source_id, "status": "succeeded"}, metadata={"pipeline_stage": "style_source_completed"}) def _after_source_terminal(self, import_id: str, ctx: RequestContext) -> None: record = self.repository.get_import(import_id) if record is None or record.status in {"cancelled", "accepted", "archived"}: return sources = self.repository.list_style_sources(import_id, include_excluded=False) if any(item.status not in STYLE_SOURCE_TERMINAL for item in sources): return succeeded = [item for item in sources if item.status == "succeeded"] if len(succeeded) < MIN_STYLE_SOURCES: self.repository.update_import(import_id, {"status": "style_source_review_required", "error": {"error_type": "insufficient_style_sources"}}) return failed = [item for item in sources if item.status in {"failed", "cancelled"}] if failed: self.repository.update_import(import_id, {"status": "style_source_review_required", "error": {"error_type": "style_source_partial_failure", "source_ids": [item.source_id for item in failed]}}) return try: self.create_consensus(import_id, {"automatic": True}, ctx) except Exception: latest = self.repository.get_latest_style_consensus_run(import_id) if latest is None or latest.status not in {"queued", "running", "succeeded"}: # Source recognition itself succeeded. A queue/database # failure while scheduling the next stage is represented on # the parent/consensus and must not retroactively fail the # source task that happened to cross the barrier last. failure = latest.error if latest is not None else {"error_type": "consensus_enqueue_failed"} self.repository.update_import( import_id, {"status": "style_consensus_failed", "error": failure}, ) return def _execute_consensus(self, task: Any, ctx: RequestContext) -> WorkerTaskUpdate: import_id = _required_task_value(task, "advanced_material_import_id") consensus_id = _required_task_value(task, "advanced_style_consensus_id") record = self.owner._require_import(import_id) self._require_style_set(record) consensus = self.repository.get_style_consensus_run(consensus_id) if consensus is None or consensus.import_id != import_id: raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "style consensus does not exist", {"consensus_id": consensus_id}) if consensus.status == "succeeded": return WorkerTaskUpdate(result={"consensus_id": consensus_id, "status": "succeeded"}) if consensus.status not in STYLE_CONSENSUS_EXECUTABLE or consensus.task_id != task.task_id: raise RuntimeError("style consensus no longer owns the import") consensus = self.repository.update_style_consensus_run( consensus_id, {"status": "running", "error": None}, expected_statuses={"queued", "running"}, ) if consensus is None: raise RuntimeError("style consensus could not be claimed") self.repository.update_import(import_id, {"status": "style_consensus_running"}) sources = [ self._require_source(import_id, source_id) for source_id in consensus.source_ids ] sources = [item for item in sources if item.status == "succeeded"] if len(sources) < MIN_STYLE_SOURCES: raise ApiError(ErrorCode.VALIDATION_FAILED, "style consensus lost its successful source quorum") source_by_id = {item.source_id: item for item in sources} source_reports: list[dict[str, Any]] = [] for source in sources: source_reports.append( { "source_id": source.source_id, "sort_order": source.sort_order, "prompt": source.recognition_prompt, "negative_prompt": source.recognition_negative_prompt, "tags": source.recognition_tags, "analysis": source.recognition_result, } ) style_adjustment = _optional_text( consensus.metadata.get("style_adjustment_text") or consensus.metadata.get("adjustment_text") ) style_adjustment_plan = _style_adjustment_plan( consensus.metadata.get("style_adjustment_plan"), style_adjustment, ) comparison_attempt_id = _optional_text(consensus.metadata.get("comparison_attempt_id")) comparison_consensus_id = _optional_text(consensus.metadata.get("comparison_consensus_id")) comparison_consensus = ( self.repository.get_style_consensus_run(comparison_consensus_id) if comparison_consensus_id else None ) previous_cases = ( [ item for item in self.repository.list_style_validation_cases(comparison_attempt_id) if item.import_id == import_id and item.validation_image_uri ][:3] if comparison_attempt_id else [] ) image_urls: list[str] = [] image_manifest: list[dict[str, Any]] = [] comparison_source_ids = [ item for item in _string_list(consensus.metadata.get("comparison_source_ids")) if item in source_by_id ][:3] if previous_cases and not comparison_source_ids and comparison_consensus is not None: comparison_source_ids = [ item for item in _string_list(comparison_consensus.result.get("representative_source_ids")) if item in source_by_id ][:3] if previous_cases: comparison_source_ids = comparison_source_ids or [item.source_id for item in sources[:3]] for source_id in comparison_source_ids: source = source_by_id[source_id] image_url, _, _ = _storage_image_data_url(source.source_image_uri, {}, self.storage) image_urls.append(image_url) image_manifest.append( { "image_index": len(image_urls) - 1, "kind": "source_reference", "source_id": source.source_id, "image_uri": source.source_image_uri, } ) for case in previous_cases: image_url, _, _ = _storage_image_data_url(str(case.validation_image_uri), {}, self.storage) image_urls.append(image_url) image_manifest.append( { "image_index": len(image_urls) - 1, "kind": "previous_validation", "case_id": case.case_id, "case_key": case.case_key, "image_uri": case.validation_image_uri, } ) else: for source in sources: image_url, _, _ = _storage_image_data_url(source.source_image_uri, {}, self.storage) image_urls.append(image_url) image_manifest.append( { "image_index": len(image_urls) - 1, "kind": "source_reference", "source_id": source.source_id, "image_uri": source.source_image_uri, } ) automatic_review_feedback = _aggregate_style_review_feedback(previous_cases) comparison_payload = { "attempt_id": comparison_attempt_id, "consensus_id": comparison_consensus_id, "previous_prompt": comparison_consensus.prompt if comparison_consensus is not None else None, "previous_negative_prompt": comparison_consensus.negative_prompt if comparison_consensus is not None else None, "previous_generation_capsules": ( comparison_consensus.result.get("generation_capsules") if comparison_consensus is not None else None ), "validation_cases": [ { "case_id": item.case_id, "case_key": item.case_key, "content_prompt": item.content_prompt, "final_prompt": item.final_prompt, "style_review": item.style_review, "validation_image_uri": item.validation_image_uri, } for item in previous_cases ], "automatic_review_feedback": automatic_review_feedback, } route_name = consensus.model_route or record.recognition_model_route or self.owner._recognition_route() provider = self.model_provider_runtime.vision_provider_for_route( {"route_name": route_name, "modality": "vision_recognition", "material_id": consensus_id, "image_uri": sources[0].source_image_uri} ) if provider is None: raise ApiError(ErrorCode.MODEL_CAPABILITY_UNCONFIRMED, "advanced style consensus route is unavailable", {"route_name": route_name}) request = VisionRecognitionRequest( display_name=f"{record.display_name} / cross-image style consensus", image_uri=image_urls[0], image_uris=tuple(image_urls[1:]), prompt=json.dumps( { "source_reports": source_reports, "image_manifest": image_manifest, "previous_validation": comparison_payload, "automatic_review_feedback": automatic_review_feedback, "style_adjustment_plan": style_adjustment_plan, "human_style_feedback": style_adjustment, }, ensure_ascii=False, ), metadata={ "recognition_instruction": _consensus_instruction( source_ids=[item.source_id for item in sources], style_adjustment=style_adjustment, style_adjustment_plan=style_adjustment_plan, validation_instruction=_optional_text(consensus.metadata.get("validation_instruction")), has_previous_validation=bool(previous_cases), ), "style_set": True, "consensus_id": consensus_id, "comparison_attempt_id": comparison_attempt_id, "comparison_consensus_id": comparison_consensus_id, "image_manifest": image_manifest, "style_adjustment_plan": style_adjustment_plan, "automatic_review_feedback": automatic_review_feedback, }, ) try: recognition = provider.recognize_material(request) except VisionProviderError as exc: raise ApiError(ErrorCode.GENERATION_FAILED, "advanced style cross-image analysis failed", _vision_provider_error(exc)) from None try: structures = self.normalization_service.normalize_recognition( recognition.structured_data, prompt=recognition.prompt, negative_prompt=recognition.negative_prompt, tags=recognition.tags, confidence=recognition.confidence, provider_id=recognition.provider_id, model=recognition.model, route_name=route_name, category_hint="风格", ) except MaterialNormalizationError as exc: raise ApiError(ErrorCode.GENERATION_FAILED, "style consensus returned invalid structures") from exc structures = _force_style_structures(structures) effective_prompt, effective_negative_prompt, structures, adjustment_guard = _apply_style_adjustment_guard( recognition.prompt, recognition.negative_prompt, structures, style_adjustment_plan, ) valid_ids = {item.source_id for item in sources} provider_result = recognition.structured_data if isinstance(recognition.structured_data, dict) else {} reused = consensus.metadata.get("reuse_validation_cases") validation_instruction = _optional_text(consensus.metadata.get("validation_instruction")) validation_cases = _validation_cases( provider_result.get("validation_cases"), reused, validation_instruction=validation_instruction, ) result = { "recognition": { **_recognition_metadata(recognition, route_name=route_name), "effective_prompt": effective_prompt, "effective_negative_prompt": effective_negative_prompt, }, **structures, "consensus_style": _object(provider_result.get("consensus_style")), "variable_style_features": _list(provider_result.get("variable_style_features")), "source_content_features": _list(provider_result.get("source_content_features")), "content_leakage_exclusions": _string_list(provider_result.get("content_leakage_exclusions")), "outlier_source_ids": [item for item in _string_list(provider_result.get("outlier_source_ids")) if item in valid_ids], "representative_source_ids": [item for item in _string_list(provider_result.get("representative_source_ids")) if item in valid_ids][:3] or [item.source_id for item in sources[:3]], "consensus_confidence": _calibrated_style_confidence( provider_result, recognition.confidence, structures, ), "feature_evidence": _list(provider_result.get("feature_evidence")), "prompt_priority_groups": _object(provider_result.get("prompt_priority_groups")), "scale_capsules": _object(provider_result.get("scale_capsules")), "semantic_risk_audit": _list(provider_result.get("semantic_risk_audit")), "validation_cases": validation_cases, "human_adjustments": { "style_adjustment_text": _optional_text(consensus.metadata.get("style_adjustment_text")), "validation_instruction": validation_instruction, "style_adjustment_plan": style_adjustment_plan, "guard": adjustment_guard, }, "comparison_context": comparison_payload, "automatic_review_feedback": automatic_review_feedback, "image_manifest": image_manifest, "effective_style_prompt": effective_prompt, "effective_style_negative_prompt": effective_negative_prompt, "source_ids": [item.source_id for item in sources], } updated = self.repository.update_style_consensus_run( consensus_id, { "status": "succeeded", "provider_id": recognition.provider_id, "provider_model": recognition.model, "prompt": effective_prompt, "negative_prompt": effective_negative_prompt, "tags": recognition.tags, "result": result, "error": None, "metadata": { **consensus.metadata, "style_adjustment_plan": style_adjustment_plan, "comparison_attempt_id": comparison_attempt_id, "comparison_consensus_id": comparison_consensus_id, "image_manifest": image_manifest, }, }, expected_statuses={"running"}, ) if updated is None: raise RuntimeError("style consensus result arrived after cancellation or replacement") self.repository.update_import( import_id, { "status": "ready_for_validation", "recognition_prompt": effective_prompt, "recognition_negative_prompt": effective_negative_prompt, "recognition_tags": recognition.tags, "recognition_result": result, "prompt_revision": consensus.revision, "error": None, "metadata": {**record.metadata, "current_consensus_id": consensus_id}, }, ) try: attempt, cases, tasks = self._queue_validation_batch( self.owner._require_import(import_id), updated, ctx, ) except Exception as exc: # The reusable consensus is already valid. Keep it and expose a # retryable validation-stage failure instead of forcing another # paid/expensive cross-image analysis. self.repository.update_import( import_id, {"status": "validation_failed", "error": _safe_failure(exc)}, ) raise return WorkerTaskUpdate( result={"import_id": import_id, "consensus_id": consensus_id, "attempt_id": attempt.attempt_id, "case_ids": [item.case_id for item in cases], "next_task_ids": [item.task_id for item in tasks]}, metadata={"pipeline_stage": "style_consensus_completed"}, ) def _queue_validation_batch(self, record: Any, consensus: Any, ctx: RequestContext): route_name = _optional_text(record.metadata.get("generation_model_route")) or self.owner._generation_route() validation_instruction = _optional_text(consensus.metadata.get("validation_instruction")) style_adjustment = _optional_text(consensus.metadata.get("style_adjustment_text") or consensus.metadata.get("adjustment_text")) plans = _validation_cases( consensus.result.get("validation_cases"), consensus.metadata.get("reuse_validation_cases"), validation_instruction=validation_instruction, ) leakage = _string_list(consensus.result.get("content_leakage_exclusions")) detailed_style_prompt = _detailed_style_prompt(consensus.result, consensus.prompt) detailed_style_negative = _detailed_style_negative_prompt(consensus.result, consensus.negative_prompt) negative = _join_prompt( detailed_style_negative, "exact source character identity, exact source costume design, exact source pose, exact source setting, " "generic semi-realistic reinterpretation, realistic facial anatomy when absent from the source style, text, watermark", ) case_payloads = [] for index, plan in enumerate(plans): content_prompt = str(plan["content_prompt"]).strip() case_key = str(plan["case_key"]) scale_style_prompt = _scale_specific_style_prompt(consensus.result, case_key) scale_style_negative = _scale_specific_style_negative_prompt(consensus.result, case_key) case_negative = _join_prompt(negative, scale_style_negative) final_prompt = _join_prompt( detailed_style_prompt, scale_style_prompt, content_prompt, _scale_transfer_instruction(case_key), "transfer the complete shared visual grammar, including facial proportions, eye geometry, nose and mouth simplification, " "hair strand grouping, line topology, local line colors, shading edges, palette relationships and highlight shapes; " "do not reproduce any exact source identity, costume, pose or setting; preserve the requested validation subject and composition", ) case_payloads.append( { "case_id": f"advcase_{uuid4().hex}", "case_key": case_key, "sort_order": index, "status": "queued", "content_prompt": content_prompt, "final_prompt": final_prompt, "negative_prompt": case_negative, "model_route": route_name, "seed": _style_validation_seed(index, consensus.revision, refresh_content=bool(validation_instruction)), "width": 1024, "height": 1024, "metadata": { "aspect_ratio": plan.get("aspect_ratio") or DEFAULT_VALIDATION_CASES[index]["aspect_ratio"], "style_consensus_id": consensus.consensus_id, "style_consensus_revision": consensus.revision, "style_adjustment_text": style_adjustment, "style_adjustment_plan": consensus.result.get("human_adjustments", {}).get("style_adjustment_plan", {}), "validation_instruction": validation_instruction, "content_refresh": bool(validation_instruction), "style_capsule_tier": "detailed", "effective_style_prompt": detailed_style_prompt, "effective_style_negative_prompt": detailed_style_negative, "scale_style_prompt": scale_style_prompt, "scale_style_negative_prompt": scale_style_negative, "style_compiler_version": 2, "content_leakage_exclusions": leakage, "retry_count": 0, "prompt_only": True, }, } ) attempt, cases = self.repository.create_style_validation_batch( { "attempt_id": f"advattempt_{uuid4().hex}", "import_id": record.import_id, "status": "running", "adjustment_text": _review_adjustment_summary(style_adjustment, validation_instruction), "prompt": detailed_style_prompt or consensus.prompt or record.recognition_prompt, "negative_prompt": negative, "model_route": route_name, "seed": _style_validation_seed(0, consensus.revision, refresh_content=bool(validation_instruction)), "width": 1024, "height": 1024, "metadata": { "style_consensus_id": consensus.consensus_id, "style_consensus_revision": consensus.revision, "style_set": True, "style_adjustment_text": style_adjustment, "validation_instruction": validation_instruction, }, }, case_payloads, ) tasks = [] for case in cases: try: tasks.append(self._queue_validation_case(record, case, ctx)) except Exception as exc: self.repository.update_style_validation_case( case.case_id, {"status": "failed", "task_id": None, "error": _safe_failure(exc)}, expected_statuses={"queued"}, ) self.repository.update_import( record.import_id, { "status": "validating", "current_attempt_id": attempt.attempt_id, "error": None, "metadata": {**record.metadata, "active_task_ids": [item.task_id for item in tasks], "current_consensus_id": consensus.consensus_id}, }, ) # All three task insertions may fail before any worker exists to run # the aggregation callback. Re-evaluate immediately so the batch is # retryable instead of remaining in a false "validating" state. _, attempt, cases = self.repository.finalize_style_validation_batch_if_ready( record.import_id, attempt.attempt_id, ) return attempt, cases, tasks def _queue_validation_case(self, record: Any, case: Any, ctx: RequestContext): retry_count = int(case.metadata.get("retry_count") or 0) task = self.queue_service.create_task( { "task_type": "advanced_style_validation_generation", "status": "queued", "model_route": case.model_route or self.owner._generation_route(), "idempotency_key": f"advanced-style-validation:{case.case_id}:{retry_count}", "request": {"import_id": record.import_id, "attempt_id": case.attempt_id, "case_id": case.case_id, "operation": "validate_style_transfer"}, "metadata": { "source": "advanced_material", "advanced_material_import_id": record.import_id, "advanced_material_attempt_id": case.attempt_id, "advanced_style_validation_case_id": case.case_id, "stage": "style_validation_generation", "task_summary": f"进阶画风/{record.display_name}/{case.case_key}迁移验证", }, }, ctx, ) self.repository.update_style_validation_case(case.case_id, {"status": "queued", "task_id": task.task_id, "error": None}) return task def _execute_validation_case(self, task: Any, ctx: RequestContext) -> WorkerTaskUpdate: import_id = _required_task_value(task, "advanced_material_import_id") attempt_id = _required_task_value(task, "advanced_material_attempt_id") case_id = _required_task_value(task, "advanced_style_validation_case_id") record = self.owner._require_import(import_id) self._require_style_set(record) attempt = self.owner._require_attempt(import_id, attempt_id) case = self._require_case(import_id, case_id) if case.status == "succeeded" and case.validation_image_uri: return WorkerTaskUpdate(result={"case_id": case_id, "status": "succeeded"}) if case.status not in STYLE_CASE_EXECUTABLE or case.task_id != task.task_id: raise RuntimeError("style validation case no longer owns the task") case = self.repository.update_style_validation_case(case_id, {"status": "running", "error": None}, expected_statuses={"queued", "running"}) if case is None: raise RuntimeError("style validation case could not be claimed") self.repository.update_attempt(attempt_id, {"status": "running", "error": None}) self.repository.update_import(import_id, {"status": "validating", "error": None}) case_attempt = replace(attempt, prompt=case.final_prompt, negative_prompt=case.negative_prompt, model_route=case.model_route) requested_route = case.model_route or self.owner._generation_route() governance = self.owner._govern_validation_prompt(record=record, attempt=case_attempt, requested_route=requested_route, ctx=ctx) route_name = str(governance["selected_route"]) resolved_route = self.owner._resolve_generation_route(route_name) cost_guard = self.owner._check_validation_budget(route_name, resolved_route) node = WorkflowNode( node_id=f"advanced-style:{case_id}", workflow_id=f"advanced-style:{import_id}", node_key="advanced_style_transfer_validation", title=f"进阶画风迁移验证 / {case.case_key}", description=None, step_name="style_validation", node_type="generation", status="running", branch_name="main", prompt=governance["prompt"], negative_prompt=governance["negative_prompt"], model_route=route_name, selected_image_id=None, sort_order=case.sort_order, metadata={"advanced_material": True, "style_set": True, "prompt_only": True}, created_at=case.created_at, updated_at=case.updated_at, ) request = { "count": 1, "aspect_ratio": str(case.metadata.get("aspect_ratio") or "1:1"), "quality": "standard", "seed": int(case.seed or STYLE_VALIDATION_SEEDS[case.sort_order]), "model_route": route_name, "resolved_model_route": resolved_route, "allow_provider_fallback": False, "expanded_prompt": governance["prompt"], "expanded_negative_prompt": governance["negative_prompt"], "prompt_governance": governance["snapshot"], **({"cost_guard": cost_guard} if cost_guard else {}), # Intentionally no image/input_images key. This validates style # transfer from the consensus text into unrelated content. "output_scope": { "kind": "advanced_style_validation", "import_id": import_id, "attempt_id": attempt_id, "case_id": case_id, "case_key": case.case_key, }, } assets = [] try: try: assets = self.single_flow_engine.generate(node, task, request) except ImageProviderError as exc: fallback = self.owner._content_safety_fallback( exc=exc, runtime_request=request, governance=governance, requested_route=requested_route, record=record, ctx=ctx, ) if fallback is None: raise route_name = fallback["model_route"] resolved_route = fallback["resolved_model_route"] request = fallback["request"] assets = self.single_flow_engine.generate(node, task, request) except Exception: for asset in assets: self.owner._remove_uri(str(getattr(asset, "image_uri", "") or "")) self.owner._remove_uri(str(getattr(asset, "thumbnail_uri", "") or "")) raise if len(assets) != 1: raise ImageProviderError("advanced style validation must return exactly one image", provider_id=str(resolved_route.get("provider_id") or "unknown"), error_type="invalid_response") asset = assets[0] latest = self.repository.get_style_validation_case(case_id) if latest is None or latest.status != "running" or latest.task_id != task.task_id: self.owner._remove_uri(asset.image_uri) self.owner._remove_uri(asset.thumbnail_uri) raise RuntimeError("style validation result arrived after cancellation or retry") style_review, fidelity_score = self._review_validation_image( record=record, case=case, validation_image_uri=asset.image_uri, ) updated = self.repository.update_style_validation_case( case_id, { "status": "succeeded", "model_route": route_name, "provider_id": asset.metadata.get("provider_id") or resolved_route.get("provider_id"), "provider_model": asset.metadata.get("provider_model") or resolved_route.get("model_id"), "width": asset.width, "height": asset.height, "validation_image_uri": asset.image_uri, "validation_thumbnail_uri": asset.thumbnail_uri, "usage": asset.metadata.get("usage") or {}, "style_review": style_review, "fidelity_score": fidelity_score, "metadata": { **case.metadata, "generation": asset.metadata, "prompt_governance": governance["snapshot"], "prompt_only": True, "automatic_style_review": style_review, }, "error": None, }, expected_statuses={"running"}, ) if updated is None: self.owner._remove_uri(asset.image_uri) self.owner._remove_uri(asset.thumbnail_uri) raise RuntimeError("style validation result could not be published") current_import, current_attempt, cases = self.repository.finalize_style_validation_batch_if_ready(import_id, attempt_id) review_scores = [float(item.fidelity_score) for item in cases if item.fidelity_score is not None] if review_scores: current_attempt = self.repository.update_attempt( attempt_id, { "fidelity_score": sum(review_scores) / len(review_scores), "metadata": { **current_attempt.metadata, "automatic_style_review": { "reviewed_cases": len(review_scores), "total_cases": len(cases), "average_fidelity_score": sum(review_scores) / len(review_scores), }, }, }, ) or current_attempt if current_attempt.status == "awaiting_review": attempts = self.repository.list_attempts(import_id) previous_attempt = next( ( item for item in attempts if item.attempt_id != current_attempt.attempt_id and item.fidelity_score is not None ), None, ) comparison = _style_attempt_comparison( current_attempt=current_attempt, current_cases=cases, previous_attempt=previous_attempt, previous_cases=( self.repository.list_style_validation_cases(previous_attempt.attempt_id) if previous_attempt is not None else [] ), ) current_attempt = self.repository.update_attempt( attempt_id, { "metadata": { **current_attempt.metadata, "style_regression_evaluation": comparison, } }, ) or current_attempt return WorkerTaskUpdate( result={ "import_id": import_id, "attempt_id": attempt_id, "case_id": case_id, "status": updated.status, "batch_status": current_attempt.status, "validation_image_uri": updated.validation_image_uri, "fidelity_score": updated.fidelity_score, }, metadata={"pipeline_stage": "style_validation_case_completed" if current_attempt.status != "awaiting_review" else "awaiting_human_review"}, ) def _review_validation_image( self, *, record: Any, case: Any, validation_image_uri: str, ) -> tuple[dict[str, Any], float | None]: consensus_id = _optional_text(case.metadata.get("style_consensus_id")) consensus = self.repository.get_style_consensus_run(consensus_id) if consensus_id else None if consensus is None or consensus.status != "succeeded": return {"status": "skipped", "reason": "style_consensus_unavailable"}, None sources = [item for item in self.repository.list_style_sources(record.import_id) if item.status == "succeeded"] source_by_id = {item.source_id: item for item in sources} representative_ids = [ item for item in _string_list(consensus.result.get("representative_source_ids")) if item in source_by_id ][:3] representative_ids = representative_ids or [item.source_id for item in sources[:3]] image_urls: list[str] = [] image_manifest: list[dict[str, Any]] = [] try: for source_id in representative_ids: source = source_by_id[source_id] image_url, _, _ = _storage_image_data_url(source.source_image_uri, {}, self.storage) image_urls.append(image_url) image_manifest.append( { "image_index": len(image_urls) - 1, "kind": "source_reference", "source_id": source_id, } ) validation_url, _, _ = _storage_image_data_url(validation_image_uri, {}, self.storage) image_urls.append(validation_url) image_manifest.append( { "image_index": len(image_urls) - 1, "kind": "generated_validation", "case_id": case.case_id, "case_key": case.case_key, } ) except Exception as exc: return {"status": "review_failed", "error": _safe_failure(exc)}, None route_name = consensus.model_route or record.recognition_model_route or self.owner._recognition_route() provider = self.model_provider_runtime.vision_provider_for_route( { "route_name": route_name, "modality": "vision_recognition", "material_id": case.case_id, "image_uri": validation_image_uri, } ) if provider is None: return {"status": "review_failed", "reason": "vision_route_unavailable", "route_name": route_name}, None request = VisionRecognitionRequest( display_name=f"{record.display_name} / {case.case_key} style fidelity review", image_uri=image_urls[0], image_uris=tuple(image_urls[1:]), prompt=json.dumps( { "image_manifest": image_manifest, "consensus_prompt": consensus.prompt, "consensus_negative_prompt": consensus.negative_prompt, "generation_capsules": consensus.result.get("generation_capsules"), "prompt_priority_groups": consensus.result.get("prompt_priority_groups"), "scale_capsules": consensus.result.get("scale_capsules"), "semantic_risk_audit": consensus.result.get("semantic_risk_audit"), "validation_content_prompt": case.content_prompt, "actual_generation_prompt": case.final_prompt, "validation_scenario": case.case_key, }, ensure_ascii=False, ), metadata={ "recognition_instruction": _style_fidelity_review_instruction(), "style_validation_review": True, "style_consensus_id": consensus.consensus_id, "style_validation_case_id": case.case_id, "image_manifest": image_manifest, }, ) try: recognition = provider.recognize_material(request) except VisionProviderError as exc: return {"status": "review_failed", "error": _vision_provider_error(exc)}, None payload = recognition.structured_data if isinstance(recognition.structured_data, dict) else {} dimension_scores = _normalize_style_dimension_scores(payload.get("dimension_scores")) provider_score = _score(payload.get("fidelity_score"), recognition.confidence) score, score_meta = _weighted_style_fidelity_score(case.case_key, dimension_scores, provider_score) prompt_patch = _normalize_style_prompt_patch( payload.get("prompt_patch"), correction_prompt=_optional_text(payload.get("correction_prompt")) or recognition.prompt, negative_correction_prompt=_optional_text(payload.get("negative_correction_prompt")) or recognition.negative_prompt, ) review = { "status": "succeeded", "schema_version": STYLE_REVIEW_SCHEMA_VERSION, "provider_id": recognition.provider_id, "provider_model": recognition.model, "fidelity_score": score, "provider_fidelity_score": provider_score, "score_calibration": score_meta, "dimension_scores": dimension_scores, "matches": _string_list(payload.get("matches")), "mismatches": _string_list(payload.get("mismatches")), "style_deltas": _normalize_style_deltas(payload.get("style_deltas"), case_key=case.case_key), "prompt_patch": prompt_patch, "semantic_risks": _normalize_semantic_risks(payload.get("semantic_risks")), "content_leakage": _string_list(payload.get("content_leakage")), "correction_prompt": _optional_text(payload.get("correction_prompt")) or recognition.prompt, "negative_correction_prompt": _optional_text(payload.get("negative_correction_prompt")) or recognition.negative_prompt, "description": recognition.description, "image_manifest": image_manifest, } return review, score def _require_style_set(self, record: Any) -> None: if not self.is_style_set(record): raise ApiError(ErrorCode.VALIDATION_FAILED, "advanced material import is not a multi-image style set", {"import_id": record.import_id}) def _require_sources_editable(self, record: Any) -> None: if record.status in {"accepted", "archived", "cancelled"}: raise ApiError( ErrorCode.VALIDATION_FAILED, "advanced style source set is no longer editable", {"import_id": record.import_id, "status": record.status}, ) latest = self.repository.get_latest_style_consensus_run(record.import_id) if latest is not None and latest.status not in {"failed", "cancelled"}: raise ApiError( ErrorCode.VALIDATION_FAILED, "style sources cannot change after a consensus has started", { "import_id": record.import_id, "consensus_id": latest.consensus_id, "consensus_status": latest.status, }, ) def _require_source(self, import_id: str, source_id: str): source = self.repository.get_style_source(source_id) if source is None or source.import_id != import_id: raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "advanced style source not found", {"source_id": source_id}) return source def _require_case(self, import_id: str, case_id: str): case = self.repository.get_style_validation_case(case_id) if case is None or case.import_id != import_id: raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "advanced style validation case not found", {"case_id": case_id}) return case def _is_style_category(category: Any) -> bool: name = str(getattr(category, "name", "") or "").strip().casefold() metadata = getattr(category, "metadata", None) group = str(metadata.get("frontend_group") or "").strip().casefold() if isinstance(metadata, dict) else "" category_id = str(getattr(category, "category_id", "") or "").strip().casefold() return name in {"风格", "画风", "style"} or group in {"风格", "画风", "style"} or category_id == "cat_imagestudio_风格".casefold() def _single_style_instruction() -> str: return ( "Analyze only observable visual style and separate it from exact subject identity, costume, pose, props, text, " "scene and composition. Extract both surface rendering and structural style grammar. Required structural dimensions " "include face width/length and chin shape, eye-to-face ratio, eye contour and iris layers, eyelid/lash design, " "nose and mouth simplification, apparent-age stylization, head-to-body ratio, hand/anatomy simplification, hair mass " "and strand grouping, line topology/closure/taper/local color, shadow hue/band count/edge softness, skin blush and " "subsurface tones, highlight shape and placement, palette contrast/saturation/value range, texture, background detail " "rhythm and optical effects. Do not replace these observations with generic labels such as anime style, beautiful, " "high quality or vibrant. Return JSON with prompt, negative_prompt, tags, confidence, description, raw_analysis.attributes, " "normalized_asset_profile(category=style, role=style, body_slots=[global_style], attributes, must_preserve and " "forbidden_changes), generation_capsules compact/standard/detailed, and source_content_features. Detailed capsule " "parts must remain complete semantic phrases, not comma fragments. Never name an artist when traits can be described." ) def _consensus_instruction( *, source_ids: list[str], style_adjustment: str | None, style_adjustment_plan: dict[str, Any], validation_instruction: str | None, has_previous_validation: bool, ) -> str: style_clause = ( "Human style correction. Apply this only to transferable style fields, prompts and generation capsules: " f"{style_adjustment}" if style_adjustment else "" ) validation_clause = ( "Human validation-content request. Apply this to every validation_cases.content_prompt while adapting framing " f"for portrait, fullbody and novel_scene. Do not absorb it into the transferable style prompt: {validation_instruction}" if validation_instruction else "" ) comparison_clause = ( "The image_manifest labels source_reference images and previous_validation images. Compare the failed validation " "images directly against the source references, diagnose which transferable traits moved in the wrong direction, " "and revise the prompt rather than merely repeating the previous wording. Use automatic_review_feedback to distinguish " "cross-scenario failures from portrait/fullbody/novel_scene scale-specific failures. A problem repeated in two or more " "scenarios is a common-style correction; a problem isolated to one scenario belongs in that scenario's scale capsule. " if has_previous_validation else "" ) adjustment_plan_clause = ( "Treat this structured adjustment plan as a hard directional constraint. Never invert decrease, increase, remove " f"or preserve instructions: {json.dumps(style_adjustment_plan, ensure_ascii=False)}. " if style_adjustment else "" ) return ( "Read every supplied style sample and its report. Cross-compare them instead of averaging blindly. Identify " "features shared by at least 60% of samples as core style, 40-60% as variable, and lower support as content or " "an outlier. Separate character identity, age, gender/species, hair, clothing, pose, props, text, setting and " "composition from transferable style, while preserving domain-coupled structural stylization such as face proportions, " "eye geometry, nose/mouth simplification, head-to-body ratio and anatomy abstraction. Do not classify a whole subject " "class such as young characters, animal-eared characters or dresses as a negative constraint; exclude only exact source " "identity and exact designs. Return one JSON object with compatibility keys prompt, negative_prompt, " "tags, confidence and description; raw_analysis; normalized_asset_profile(category=style, role=style, " "body_slots=[global_style], attributes containing structural and rendering dimensions, and 8-16 concrete must_preserve " "phrases); generation_capsules compact/standard/detailed with intact semantic phrases; prompt_priority_groups with " "core, structural and rendering arrays totaling no more than 14 non-redundant phrases; scale_capsules keyed by portrait, " "fullbody and novel_scene; semantic_risk_audit for wording that could be literalized as an object, effect or composition; " "each semantic risk item must include original_phrase, risk, safe_rewrite and negative_guard. Prefer physically grounded " "surface/shape/placement descriptions over metaphors or object-like shorthand. consensus_style; " "variable_style_features; source_content_features; content_leakage_exclusions; outlier_source_ids; " "representative_source_ids (1-3); consensus_confidence; feature_evidence where each item has trait, " "supporting_source_ids, support_ratio and confidence; and validation_cases with exactly portrait, fullbody and " "novel_scene. Every validation content_prompt must describe a character, clothing, pose, camera and scene " "semantically different from all source samples but remain in a comparable illustration domain and apparent-age range, " "and must not contain style wording. Negative prompts must prevent semi-realistic or generic reinterpretation only when " "the source evidence supports stylized anatomy. Valid source IDs are: " f"{', '.join(source_ids)}. {comparison_clause}{adjustment_plan_clause}{style_clause} {validation_clause}" ).strip() def _force_style_structures(value: dict[str, Any]) -> dict[str, Any]: result = dict(value) profile = dict(result.get("normalized_asset_profile") or {}) profile.update({"category": "style", "role": "style", "body_slots": ["global_style"], "wear_layer": None, "stackable": False}) result["normalized_asset_profile"] = profile return result def _style_fidelity_review_instruction() -> str: return ( "The image_manifest identifies 1-3 source_reference images followed by one generated_validation image. Compare only " "transferable visual style, never subject identity or exact clothing. Score the generated image against the shared source " "style on face proportions, eye geometry and iris construction, nose/mouth simplification, apparent-age stylization, " "head-to-body ratio, hair mass and strand grouping, line topology/taper/local color, skin and blush rendering, shadow hue " "and edge softness, highlight shape, palette contrast/saturation/value range, texture/detail rhythm and optical effects. " "Separate global palette/value range from local edge, eye, hair and clothing color separation. Do not translate a local " "contrast failure into a request for globally stronger saturation. Detect phrases in the actual generation prompt that may " "have been literalized as an object, lighting effect or composition instead of a surface-bound style property. Return one " "strict JSON object with prompt, negative_prompt, confidence, description and fidelity_score; dimension_scores must use the " "fixed keys face_structure, eye_design, hair_rendering, linework, palette_global, palette_local, shading, highlights, " "anatomy_scale, texture_detail and background_rendering. Also return matches, mismatches; style_deltas as objects with " "dimension, scope(global/local/scale_specific), direction, severity, source_target, observed, evidence and scenario; " "prompt_patch with positive_additions, negative_additions, replacements, preserve and scale_overrides; semantic_risks with " "original_phrase, risk, safe_rewrite and negative_guard; content_leakage; correction_prompt and negative_correction_prompt. " "Do not reward generic prettiness, resolution, subject similarity or cinematic detail." ) def _validation_cases( provider_value: Any, reuse_value: Any, *, validation_instruction: str | None = None, ) -> list[dict[str, Any]]: candidates = ( reuse_value if not validation_instruction and isinstance(reuse_value, list) and len(reuse_value) == 3 else provider_value ) mapped: dict[str, dict[str, Any]] = {} if isinstance(candidates, list): for item in candidates: if not isinstance(item, dict): continue key = str(item.get("case_key") or item.get("type") or item.get("scenario") or "").strip() prompt = str(item.get("content_prompt") or "").strip() if key in {"portrait", "fullbody", "novel_scene"} and prompt: mapped[key] = {"case_key": key, "content_prompt": prompt, "aspect_ratio": item.get("aspect_ratio") or (item.get("metadata") or {}).get("aspect_ratio")} result: list[dict[str, Any]] = [] for default in DEFAULT_VALIDATION_CASES: selected = mapped.get(str(default["case_key"]), {}) case_key = str(default["case_key"]) content_prompt = str(selected.get("content_prompt") or default["content_prompt"]).strip() if validation_instruction: content_prompt = _validation_instruction_prompt(case_key, validation_instruction) result.append( { **default, **selected, "content_prompt": content_prompt, "aspect_ratio": selected.get("aspect_ratio") or default["aspect_ratio"], } ) return result def _validation_instruction_prompt(case_key: str, instruction: str) -> str: framing = { "portrait": ( "For this controlled portrait comparison, preserve every requested identity, hairstyle, color and wardrobe " "detail, adapting only the camera to a head-and-shoulders composition with a simple neutral background" ), "fullbody": ( "For this controlled full-body comparison, preserve every requested identity, hairstyle, color and wardrobe " "detail and show the complete character from head to toe in a simple readable environment" ), "novel_scene": ( "For this cross-scene comparison, preserve every requested identity, hairstyle, color and wardrobe detail, " "then place the same character in a clearly different wide environmental scene" ), }.get(case_key, "Preserve every requested subject and wardrobe detail in a controlled comparison composition") return _join_prompt(f"Mandatory human validation request: {instruction}", framing) def _style_validation_seed(index: int, revision: int, *, refresh_content: bool) -> int: base = STYLE_VALIDATION_SEEDS[index] return base + max(1, int(revision)) * 1000 if refresh_content else base def _review_adjustment_summary(style_adjustment: str | None, validation_instruction: str | None) -> str | None: parts = [] if style_adjustment: parts.append(f"画风修正:{style_adjustment}") if validation_instruction: parts.append(f"验证内容:{validation_instruction}") return "\n".join(parts) or None _STYLE_TRAIT_ALIASES: dict[str, tuple[str, ...]] = { "color contrast": ("颜色对比", "色彩对比", "明暗对比", "color contrast", "colour contrast", "contrast"), "color saturation": ("颜色饱和", "色彩饱和", "饱和度", "鲜艳度", "color saturation", "colour saturation", "saturation"), "brightness": ("亮度", "明度", "brightness", "luminance"), "shadow intensity": ("阴影强度", "阴影浓度", "阴影", "shadow intensity", "shadow strength", "shadows"), "highlight intensity": ("高光强度", "高光", "highlight intensity", "highlight strength", "highlights"), "line weight": ("线条粗细", "线宽", "线条", "line weight", "line thickness"), "detail density": ("细节密度", "细节", "detail density", "level of detail"), "texture intensity": ("纹理强度", "纹理", "texture intensity", "texture"), } _STYLE_DECREASE_MARKERS = ( "太强", "太重", "太浓", "太高", "太过", "过于", "过度", "降低", "减弱", "减少", "收敛", "too strong", "too intense", "too high", "overly", "excessive", "reduce", "decrease", "less", ) _STYLE_INCREASE_MARKERS = ( "太弱", "太淡", "太低", "不足", "加强", "增强", "增加", "提高", "too weak", "too low", "insufficient", "increase", "strengthen", "more", ) _STYLE_REMOVE_MARKERS = ("不要", "去掉", "移除", "删除", "取消", "remove", "eliminate", "without") _STYLE_PRESERVE_MARKERS = ("保持", "保留", "不要改变", "维持", "preserve", "retain", "keep") _STYLE_DECREASE_GUARDS: dict[str, dict[str, list[str]]] = { "color contrast": { "positive_forbidden": [ "intense color contrast", "extreme color contrast", "high color contrast", "high contrast", "strong contrast", "dramatic contrast", "extreme color dynamics", ], "negative_forbidden": ["low contrast", "washed out", "flat contrast", "muted contrast"], "positive_add": ["balanced moderate color contrast", "restrained color separation"], "negative_add": ["excessive color contrast", "extreme color dynamics", "oversaturated color separation"], }, "color saturation": { "positive_forbidden": ["high saturation", "highly saturated", "extreme saturation", "oversaturated", "vivid saturated"], "negative_forbidden": ["low saturation", "desaturated", "muted colors", "washed out"], "positive_add": ["controlled moderate color saturation", "restrained chroma"], "negative_add": ["oversaturated colors", "extreme chroma", "neon color overload"], }, "brightness": { "positive_forbidden": ["extreme brightness", "very bright", "blown-out highlights"], "negative_forbidden": ["dim", "dark exposure", "underexposed"], "positive_add": ["balanced moderate brightness"], "negative_add": ["excessive brightness", "overexposure"], }, "shadow intensity": { "positive_forbidden": ["heavy shadows", "deep harsh shadows", "intense shadows", "strong shadows"], "negative_forbidden": ["weak shadows", "shadowless", "flat lighting"], "positive_add": ["controlled moderate shadow intensity"], "negative_add": ["excessively heavy shadows", "crushed shadow detail"], }, "highlight intensity": { "positive_forbidden": ["intense highlights", "extreme highlights", "strong glossy highlights"], "negative_forbidden": ["no highlights", "dull highlights"], "positive_add": ["controlled restrained highlights"], "negative_add": ["blown-out highlights", "excessive glossy glare"], }, } def _parse_style_adjustment(value: str | None) -> dict[str, Any]: text = _optional_text(value) plan: dict[str, Any] = { "increase": [], "decrease": [], "remove": [], "preserve": [], "unparsed_feedback": [], "raw_text": text, "parser_version": 1, } if not text: return plan matched = False clauses = [item.strip() for item in re.split(r"[,,。;;\n]+", text.casefold()) if item.strip()] for clause in clauses: traits = [ trait for trait, aliases in _STYLE_TRAIT_ALIASES.items() if any(alias.casefold() in clause for alias in aliases) ] if not traits: continue matched = True decrease_not_remove = any(marker in clause for marker in ("不要太", "不要过", "not too")) if any(marker in clause for marker in _STYLE_PRESERVE_MARKERS): direction = "preserve" elif any(marker in clause for marker in _STYLE_REMOVE_MARKERS) and not decrease_not_remove: direction = "remove" elif decrease_not_remove or any(marker in clause for marker in _STYLE_DECREASE_MARKERS): direction = "decrease" elif any(marker in clause for marker in _STYLE_INCREASE_MARKERS): direction = "increase" else: plan["unparsed_feedback"].append(clause) continue for trait in traits: if trait not in plan[direction]: plan[direction].append(trait) if not matched: plan["unparsed_feedback"].append(text) return plan def _style_adjustment_plan(value: Any, fallback_text: str | None) -> dict[str, Any]: if not isinstance(value, dict): return _parse_style_adjustment(fallback_text) result = { "increase": _string_list(value.get("increase")), "decrease": _string_list(value.get("decrease")), "remove": _string_list(value.get("remove")), "preserve": _string_list(value.get("preserve")), "unparsed_feedback": _string_list(value.get("unparsed_feedback")), "raw_text": _optional_text(value.get("raw_text")) or _optional_text(fallback_text), "parser_version": int(value.get("parser_version") or 1), } if not any(result[key] for key in ("increase", "decrease", "remove", "preserve", "unparsed_feedback")): return _parse_style_adjustment(fallback_text) return result def _apply_style_adjustment_guard( prompt: str | None, negative_prompt: str | None, structures: dict[str, Any], plan: dict[str, Any], ) -> tuple[str, str | None, dict[str, Any], dict[str, Any]]: positive = str(prompt or "").strip() negative = _optional_text(negative_prompt) guarded = deepcopy(structures) removed_positive: list[str] = [] removed_negative: list[str] = [] positive_additions: list[str] = [] negative_additions: list[str] = [] for trait in _string_list(plan.get("decrease")): rules = _STYLE_DECREASE_GUARDS.get( trait, { "positive_forbidden": [f"extreme {trait}", f"intense {trait}", f"high {trait}", f"strong {trait}"], "negative_forbidden": [f"low {trait}", f"weak {trait}"], "positive_add": [f"balanced moderate {trait}", f"restrained {trait}"], "negative_add": [f"excessive {trait}", f"extreme {trait}"], }, ) positive, removed = _remove_prompt_phrases(positive, rules["positive_forbidden"]) removed_positive.extend(removed) negative, removed = _remove_prompt_phrases(negative, rules["negative_forbidden"]) removed_negative.extend(removed) positive_additions.extend(rules["positive_add"]) negative_additions.extend(rules["negative_add"]) for trait in _string_list(plan.get("increase")): positive_additions.append(f"clearly pronounced {trait}") negative, removed = _remove_prompt_phrases(negative, [f"high {trait}", f"strong {trait}", f"pronounced {trait}"]) removed_negative.extend(removed) for trait in _string_list(plan.get("remove")): positive, removed = _remove_prompt_phrases(positive, [trait]) removed_positive.extend(removed) negative_additions.append(trait) for trait in _string_list(plan.get("preserve")): positive_additions.append(f"preserve source-reference {trait}") positive = _join_prompt(positive, *positive_additions) negative = _join_prompt(negative, *negative_additions) or None capsules = guarded.get("generation_capsules") if isinstance(capsules, dict): for tier, raw_capsule in list(capsules.items()): if not isinstance(raw_capsule, dict): continue capsule = dict(raw_capsule) capsule_positive_parts = _prompt_parts(capsule.get("prompt_parts")) capsule_negative_parts = _prompt_parts(capsule.get("negative_parts")) for trait in _string_list(plan.get("decrease")): rules = _STYLE_DECREASE_GUARDS.get( trait, { "positive_forbidden": [f"extreme {trait}", f"intense {trait}", f"high {trait}", f"strong {trait}"], "negative_forbidden": [f"low {trait}", f"weak {trait}"], "positive_add": [f"balanced moderate {trait}", f"restrained {trait}"], "negative_add": [f"excessive {trait}", f"extreme {trait}"], }, ) capsule_positive_parts, _ = _remove_forbidden_from_parts( capsule_positive_parts, rules["positive_forbidden"], ) capsule_negative_parts, _ = _remove_forbidden_from_parts( capsule_negative_parts, rules["negative_forbidden"], ) capsule["prompt_parts"] = _unique_prompt_parts([*capsule_positive_parts, *positive_additions]) capsule["negative_parts"] = _unique_prompt_parts([*capsule_negative_parts, *negative_additions]) capsule["style_adjustment_guarded"] = True capsules[tier] = capsule return ( positive, negative, guarded, { "applied": bool(positive_additions or negative_additions or removed_positive or removed_negative), "removed_positive_parts": list(dict.fromkeys(removed_positive)), "removed_negative_parts": list(dict.fromkeys(removed_negative)), "positive_additions": list(dict.fromkeys(positive_additions)), "negative_additions": list(dict.fromkeys(negative_additions)), }, ) def _remove_prompt_phrases(value: str | None, forbidden: list[str]) -> tuple[str, list[str]]: parts = [item.strip() for item in re.split(r"[,;\n]+", str(value or "")) if item.strip()] removed = [item for item in parts if any(token.casefold() in item.casefold() for token in forbidden)] kept = [item for item in parts if item not in removed] return ", ".join(kept), removed def _prompt_parts(value: Any) -> list[str]: if isinstance(value, str): text = value.strip() return [text] if text else [] if not isinstance(value, (list, tuple, set)): return [] return _unique_prompt_parts([str(item).strip() for item in value if str(item).strip()]) def _unique_prompt_parts(values: list[str]) -> list[str]: result: list[str] = [] seen: set[str] = set() for value in values: text = str(value or "").strip(" ,;") key = text.casefold() if text and key not in seen: seen.add(key) result.append(text) return result def _remove_forbidden_from_parts(parts: list[str], forbidden: list[str]) -> tuple[list[str], list[str]]: kept: list[str] = [] removed: list[str] = [] for part in parts: rewritten = part for phrase in forbidden: pattern = re.compile(re.escape(phrase), re.IGNORECASE) if pattern.search(rewritten): removed.append(phrase) rewritten = pattern.sub("", rewritten) rewritten = re.sub(r"\s*,\s*,+", ", ", rewritten).strip(" ,;") if rewritten: kept.append(rewritten) return _unique_prompt_parts(kept), list(dict.fromkeys(removed)) def _normalize_style_dimension_scores(value: Any) -> dict[str, float]: if not isinstance(value, dict): return {} collected: dict[str, list[float]] = {} for raw_key, raw_value in value.items(): key = _canonical_style_dimension(raw_key) if key is None: continue candidate = raw_value.get("score") if isinstance(raw_value, dict) else raw_value score = _score(candidate) if score is not None: collected.setdefault(key, []).append(score) return {key: sum(scores) / len(scores) for key, scores in collected.items() if scores} def _canonical_style_dimension(value: Any) -> str | None: normalized = re.sub(r"[^a-z0-9]+", "_", str(value or "").strip().casefold()).strip("_") if not normalized: return None for canonical in STYLE_REVIEW_DIMENSIONS: aliases = (canonical, *STYLE_REVIEW_DIMENSION_ALIASES.get(canonical, ())) if normalized in {re.sub(r"[^a-z0-9]+", "_", alias.casefold()).strip("_") for alias in aliases}: return canonical return None def _weighted_style_fidelity_score( case_key: Any, scores: dict[str, float], provider_score: float | None, ) -> tuple[float | None, dict[str, Any]]: weights = STYLE_REVIEW_WEIGHTS.get(str(case_key), STYLE_REVIEW_WEIGHTS["novel_scene"]) available_weight = sum(weights.get(key, 0.0) for key in scores) if available_weight > 0: computed = sum(scores[key] * weights.get(key, 0.0) for key in scores) / available_weight if provider_score is not None and available_weight < 0.75: score = computed * available_weight + provider_score * (1.0 - available_weight) else: score = computed if available_weight < 0.5: score = min(score, 0.65 + 0.35 * available_weight) source = "server_weighted_dimensions" else: score = provider_score computed = None source = "provider_fallback" return ( _score(score), { "schema_version": STYLE_REVIEW_SCHEMA_VERSION, "source": source, "scenario": str(case_key), "dimension_coverage": round(available_weight, 4), "computed_dimension_score": _score(computed), "provider_score": provider_score, "missing_dimensions": [key for key in STYLE_REVIEW_DIMENSIONS if key not in scores and weights.get(key, 0.0) > 0], }, ) def _normalize_style_deltas(value: Any, *, case_key: Any) -> list[dict[str, Any]]: if not isinstance(value, list): return [] result: list[dict[str, Any]] = [] for item in value: if not isinstance(item, dict): continue dimension = _canonical_style_dimension(item.get("dimension")) if dimension is None: continue scope = str(item.get("scope") or "scale_specific").strip().casefold() if scope not in {"global", "local", "scale_specific"}: scope = "scale_specific" severity = _score(item.get("severity"), 0.5) result.append( { "dimension": dimension, "scope": scope, "direction": _optional_text(item.get("direction")), "severity": severity, "source_target": _optional_text(item.get("source_target")), "observed": _optional_text(item.get("observed")), "evidence": _optional_text(item.get("evidence")), "scenario": _optional_text(item.get("scenario")) or str(case_key), } ) return result def _normalize_style_prompt_patch( value: Any, *, correction_prompt: str | None, negative_correction_prompt: str | None, ) -> dict[str, Any]: payload = value if isinstance(value, dict) else {} replacements = [] for item in _list(payload.get("replacements")): if not isinstance(item, dict): continue original = _optional_text(item.get("from") or item.get("original_phrase")) rewrite = _optional_text(item.get("to") or item.get("safe_rewrite")) if original and rewrite and original.casefold() != rewrite.casefold(): replacements.append({"from": original, "to": rewrite, "reason": _optional_text(item.get("reason"))}) positive = _prompt_parts(payload.get("positive_additions")) negative = _prompt_parts(payload.get("negative_additions")) if not positive and correction_prompt: positive = [correction_prompt] if not negative and negative_correction_prompt: negative = [negative_correction_prompt] scale_overrides: dict[str, Any] = {} raw_scales = payload.get("scale_overrides") if isinstance(raw_scales, dict): for case_key in ("portrait", "fullbody", "novel_scene"): raw = raw_scales.get(case_key) if isinstance(raw, dict): scale_overrides[case_key] = { "positive_additions": _prompt_parts(raw.get("positive_additions") or raw.get("prompt_parts")), "negative_additions": _prompt_parts(raw.get("negative_additions") or raw.get("negative_parts")), } elif raw: scale_overrides[case_key] = {"positive_additions": _prompt_parts(raw), "negative_additions": []} return { "positive_additions": _unique_prompt_parts(positive), "negative_additions": _unique_prompt_parts(negative), "replacements": replacements, "preserve": _prompt_parts(payload.get("preserve")), "scale_overrides": scale_overrides, } def _normalize_semantic_risks(value: Any) -> list[dict[str, Any]]: if not isinstance(value, list): return [] result = [] for item in value: if not isinstance(item, dict): continue original = _optional_text(item.get("original_phrase")) rewrite = _optional_text(item.get("safe_rewrite")) if original or rewrite: result.append( { "original_phrase": original, "risk": _optional_text(item.get("risk")), "safe_rewrite": rewrite, "negative_guard": _optional_text(item.get("negative_guard")), } ) return result def _aggregate_style_review_feedback(cases: list[Any]) -> dict[str, Any]: reviewed = [] dimension_values: dict[str, list[float]] = {} weak_scenarios: dict[str, list[str]] = {} deltas: list[dict[str, Any]] = [] prompt_patches: list[dict[str, Any]] = [] semantic_risks: list[dict[str, Any]] = [] scenario_scores: dict[str, float] = {} for case in cases: review = case.style_review if isinstance(getattr(case, "style_review", None), dict) else {} if review.get("status") != "succeeded": continue scenario = str(case.case_key) reviewed.append(str(case.case_id)) score = _score(review.get("fidelity_score"), getattr(case, "fidelity_score", None)) if score is not None: scenario_scores[scenario] = score scores = _normalize_style_dimension_scores(review.get("dimension_scores")) for dimension, dimension_score in scores.items(): dimension_values.setdefault(dimension, []).append(dimension_score) if dimension_score < 0.72: weak_scenarios.setdefault(dimension, []).append(scenario) deltas.extend(_normalize_style_deltas(review.get("style_deltas"), case_key=scenario)) patch = review.get("prompt_patch") if isinstance(patch, dict): prompt_patches.append({"scenario": scenario, **patch}) semantic_risks.extend(_normalize_semantic_risks(review.get("semantic_risks"))) recurrent = sorted(dimension for dimension, scenarios in weak_scenarios.items() if len(set(scenarios)) >= 2) scale_specific = { scenario: sorted(dimension for dimension, scenarios in weak_scenarios.items() if scenario in scenarios and dimension not in recurrent) for scenario in ("portrait", "fullbody", "novel_scene") } return { "schema_version": STYLE_REVIEW_SCHEMA_VERSION, "reviewed_case_ids": reviewed, "scenario_scores": scenario_scores, "dimension_averages": { key: sum(values) / len(values) for key, values in dimension_values.items() if values }, "recurrent_weak_dimensions": recurrent, "scale_specific_weak_dimensions": scale_specific, "style_deltas": deltas, "prompt_patches": prompt_patches, "semantic_risks": semantic_risks, "correction_policy": { "common_style": "apply only findings repeated across at least two scenarios or explicitly marked global", "scale_specific": "keep isolated findings inside the matching portrait/fullbody/novel_scene capsule", "color": "separate global palette/value range from local color separation and edge contrast", "semantic_safety": "replace object-like metaphors with surface, geometry and placement language", }, } def _style_attempt_comparison( *, current_attempt: Any, current_cases: list[Any], previous_attempt: Any | None, previous_cases: list[Any], ) -> dict[str, Any]: current_score = _score(getattr(current_attempt, "fidelity_score", None)) previous_score = _score(getattr(previous_attempt, "fidelity_score", None)) if previous_attempt is not None else None delta = current_score - previous_score if current_score is not None and previous_score is not None else None if delta is None: recommendation = "baseline" elif delta >= 0.02: recommendation = "adopt_candidate" elif delta <= -0.02: recommendation = "keep_previous_candidate" else: recommendation = "equivalent_requires_human_review" current_by_key = {str(item.case_key): _score(item.fidelity_score) for item in current_cases} previous_by_key = {str(item.case_key): _score(item.fidelity_score) for item in previous_cases} scenario_deltas = { key: current_by_key[key] - previous_by_key[key] for key in current_by_key.keys() & previous_by_key.keys() if current_by_key[key] is not None and previous_by_key[key] is not None } return { "schema_version": 1, "current_attempt_id": str(current_attempt.attempt_id), "previous_attempt_id": str(previous_attempt.attempt_id) if previous_attempt is not None else None, "current_score": current_score, "previous_score": previous_score, "score_delta": delta, "scenario_deltas": scenario_deltas, "recommendation": recommendation, "regression_threshold": 0.02, } def _detailed_style_prompt(result: Any, fallback: Any) -> str: payload = result if isinstance(result, dict) else {} capsules = payload.get("generation_capsules") if isinstance(payload.get("generation_capsules"), dict) else {} detailed = capsules.get("detailed") if isinstance(capsules.get("detailed"), dict) else {} must_preserve = _prompt_parts(detailed.get("must_preserve")) profile = payload.get("normalized_asset_profile") if isinstance(payload.get("normalized_asset_profile"), dict) else {} must_preserve = _unique_prompt_parts([*must_preserve, *_prompt_parts(profile.get("must_preserve"))]) priorities = payload.get("prompt_priority_groups") if isinstance(payload.get("prompt_priority_groups"), dict) else {} priority_parts = [ *_prompt_parts(priorities.get("core")), *_prompt_parts(priorities.get("structural")), *_prompt_parts(priorities.get("rendering")), ] parts = [*must_preserve, *priority_parts, *_prompt_parts(detailed.get("prompt_parts"))] risks = _normalize_semantic_risks(payload.get("semantic_risk_audit")) compiled = _compact_style_prompt_parts([_apply_semantic_risk_rewrites(item, risks) for item in parts], limit=14) return _join_prompt(*compiled) if compiled else str(fallback or "").strip() def _detailed_style_negative_prompt(result: Any, fallback: Any) -> str: payload = result if isinstance(result, dict) else {} capsules = payload.get("generation_capsules") if isinstance(payload.get("generation_capsules"), dict) else {} detailed = capsules.get("detailed") if isinstance(capsules.get("detailed"), dict) else {} parts = _prompt_parts(detailed.get("negative_parts")) parts.extend( item["negative_guard"] for item in _normalize_semantic_risks(payload.get("semantic_risk_audit")) if item.get("negative_guard") ) return _join_prompt(*parts) if parts else str(fallback or "").strip() def _scale_specific_style_prompt(result: Any, case_key: str) -> str: payload = result if isinstance(result, dict) else {} scales = payload.get("scale_capsules") if isinstance(payload.get("scale_capsules"), dict) else {} raw = scales.get(case_key) if isinstance(raw, dict): parts = _prompt_parts(raw.get("prompt_parts") or raw.get("positive_additions")) else: parts = _prompt_parts(raw) return _join_prompt(*_compact_style_prompt_parts(parts, limit=5)) def _scale_specific_style_negative_prompt(result: Any, case_key: str) -> str: payload = result if isinstance(result, dict) else {} scales = payload.get("scale_capsules") if isinstance(payload.get("scale_capsules"), dict) else {} raw = scales.get(case_key) return _join_prompt(*_prompt_parts(raw.get("negative_parts") or raw.get("negative_additions"))) if isinstance(raw, dict) else "" def _scale_transfer_instruction(case_key: str) -> str: return { "portrait": ( "at portrait scale preserve the source style's face contour, eye-to-face ratio, iris layer hierarchy, lash design, " "nose and mouth abstraction, hair strand grouping and surface-bound highlight placement" ), "fullbody": ( "at full-body scale preserve silhouette language, head-to-body ratio, anatomy abstraction, colored line hierarchy, " "clothing-fold shading bands and readable but non-exaggerated facial features" ), "novel_scene": ( "in a wide scene keep the character linework, local palette relationships and shading grammar distinct from the " "background while matching the source style's environment detail rhythm instead of becoming photorealistic" ), }.get(case_key, "preserve the transferable style grammar at the requested camera scale") def _apply_semantic_risk_rewrites(value: str, risks: list[dict[str, Any]]) -> str: result = str(value or "").strip() for item in risks: original = _optional_text(item.get("original_phrase")) rewrite = _optional_text(item.get("safe_rewrite")) if original and rewrite: result = re.sub(re.escape(original), rewrite, result, flags=re.IGNORECASE) return result def _compact_style_prompt_parts(values: list[str], *, limit: int) -> list[str]: compacted: list[str] = [] signatures: list[set[str]] = [] for value in _unique_prompt_parts(values): words = { item for item in re.findall(r"[a-z0-9]+", value.casefold()) if len(item) > 2 and item not in {"with", "from", "into", "style", "visual", "preserve"} } duplicate_index = None for index, existing in enumerate(signatures): if not words or not existing: continue overlap = len(words & existing) / max(1, min(len(words), len(existing))) if overlap >= 0.82: duplicate_index = index break if duplicate_index is None: compacted.append(value) signatures.append(words) elif len(value) > len(compacted[duplicate_index]): compacted[duplicate_index] = value signatures[duplicate_index] = words if len(compacted) >= limit: break return compacted def _required_task_value(task: Any, key: str) -> str: value = str(task.metadata.get(key) or "").strip() if not value: raise RuntimeError(f"advanced style task is missing {key}") return value def _join_prompt(*values: Any) -> str: return ", ".join(dict.fromkeys(str(value).strip() for value in values if str(value or "").strip())) def _optional_text(value: Any) -> str | None: text = str(value or "").strip() return text or None def _string_list(value: Any) -> list[str]: if isinstance(value, str): values = value.split(",") elif isinstance(value, (list, tuple, set)): values = value else: values = [] return list(dict.fromkeys(str(item).strip() for item in values if str(item).strip())) def _list(value: Any) -> list[Any]: return list(value) if isinstance(value, list) else [] def _object(value: Any) -> dict[str, Any]: return dict(value) if isinstance(value, dict) else {} def _score(value: Any, fallback: Any = None) -> float | None: try: number = float(value if value is not None else fallback) except (TypeError, ValueError): return None return min(max(number, 0.0), 1.0) def _calibrated_style_confidence( provider_result: dict[str, Any], fallback: Any, structures: dict[str, Any], ) -> float | None: base = _score(provider_result.get("consensus_confidence"), fallback) if base is None: return None evidence_scores: list[float] = [] for item in _list(provider_result.get("feature_evidence")): if not isinstance(item, dict): continue confidence = _score(item.get("confidence")) support = _score(item.get("support_ratio")) if confidence is not None and support is not None: evidence_scores.append(confidence * support) if evidence_scores: base = min(base, sum(evidence_scores) / len(evidence_scores) + 0.1) profile = structures.get("normalized_asset_profile") if isinstance(structures.get("normalized_asset_profile"), dict) else {} attributes = profile.get("attributes") if isinstance(profile.get("attributes"), dict) else {} structural_groups = ( ("face", "facial", "chin"), ("eye", "iris", "lash", "eyelid"), ("nose", "mouth", "lip"), ("hair", "strand"), ("anatomy", "body_ratio", "head_to_body", "hand"), ("line", "outline", "linework"), ("shadow", "shading"), ("palette", "color", "saturation", "contrast"), ) keys = [str(key).casefold() for key in attributes] covered = sum(1 for aliases in structural_groups if any(any(alias in key for alias in aliases) for key in keys)) coverage_cap = 0.55 + 0.45 * (covered / len(structural_groups)) return min(base, coverage_cap) def _optional_score(value: Any) -> float | None: return _score(value) def _safe_failure(exc: Exception) -> dict[str, Any]: text = " ".join(str(exc or type(exc).__name__).split()) return {"error_type": type(exc).__name__, "message": text[:500] or type(exc).__name__} def _missing_queue_task_failure(task_id: Any, stage: str) -> dict[str, Any]: return { "error_type": "queue_task_missing", "message": "关联的队列记录已被删除;可重新入队、排除样本或删除整个导入。", "stage": stage, "task_id": str(task_id or "").strip() or None, "retryable": True, }