"""Persistence for isolated advanced-material imports and validation attempts.""" from __future__ import annotations import json from typing import Any from uuid import uuid4 from backend.dto.advanced_material_dto import ( AdvancedMaterial, AdvancedMaterialImport, AdvancedMaterialValidationAttempt, AdvancedStyleConsensusRun, AdvancedStyleSource, AdvancedStyleValidationCase, ) from database.db_helper import Database IMPORT_COLUMNS = """ import_id, category_id, display_name, source_image_uri, source_thumbnail_uri, status, recognition_prompt, recognition_negative_prompt, recognition_tags_json, recognition_result_json, recognition_model_route, prompt_revision, current_attempt_id, accepted_material_id, idempotency_key, created_by, error_json, metadata_json, created_at, updated_at """ ATTEMPT_COLUMNS = """ attempt_id, import_id, attempt_number, status, adjustment_text, prompt, negative_prompt, model_route, provider_id, provider_model, task_id, validation_image_uri, validation_thumbnail_uri, seed, width, height, usage_json, fidelity_score, decision, decision_notes, error_json, metadata_json, created_at, updated_at, completed_at, decided_at """ MATERIAL_COLUMNS = """ material_id, import_id, accepted_attempt_id, category_id, display_name, source_image_uri, source_thumbnail_uri, validation_image_uri, validation_thumbnail_uri, prompt, negative_prompt, tags_json, priority, status, capsule_json, metadata_json, accepted_at, archived_at, created_at, updated_at """ STYLE_SOURCE_COLUMNS = """ source_id, import_id, sort_order, is_primary, source_image_uri, source_thumbnail_uri, status, recognition_model_route, provider_id, provider_model, task_id, recognition_prompt, recognition_negative_prompt, recognition_tags_json, recognition_result_json, error_json, metadata_json, created_at, updated_at, completed_at, excluded_at """ STYLE_CONSENSUS_COLUMNS = """ consensus_id, import_id, revision, status, task_id, model_route, provider_id, provider_model, source_ids_json, prompt, negative_prompt, tags_json, result_json, error_json, metadata_json, created_at, updated_at, completed_at """ STYLE_VALIDATION_CASE_COLUMNS = """ case_id, attempt_id, import_id, case_key, sort_order, status, task_id, content_prompt, final_prompt, negative_prompt, model_route, provider_id, provider_model, seed, width, height, validation_image_uri, validation_thumbnail_uri, usage_json, style_review_json, fidelity_score, error_json, metadata_json, created_at, updated_at, completed_at """ class AdvancedMaterialRepository: def __init__(self, database: Database): self.database = database @property def placeholder(self) -> str: return self.database._placeholder def create_import(self, payload: dict[str, Any]) -> AdvancedMaterialImport: import_id = _payload_id(payload, "import_id", "advimp") placeholder = self.placeholder conn = self.database.connect() try: conn.execute( f""" INSERT INTO advanced_material_imports ( import_id, category_id, display_name, source_image_uri, source_thumbnail_uri, status, recognition_prompt, recognition_negative_prompt, recognition_tags_json, recognition_result_json, recognition_model_route, prompt_revision, current_attempt_id, accepted_material_id, idempotency_key, created_by, error_json, metadata_json ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( import_id, payload.get("category_id"), str(payload["display_name"]), str(payload["source_image_uri"]), payload.get("source_thumbnail_uri"), payload.get("status", "pending_recognition"), payload.get("recognition_prompt"), payload.get("recognition_negative_prompt"), _json_or_none(payload.get("recognition_tags") or []), _json_or_none(payload.get("recognition_result")), payload.get("recognition_model_route"), int(payload.get("prompt_revision", 0) or 0), payload.get("current_attempt_id"), payload.get("accepted_material_id"), payload.get("idempotency_key"), payload.get("created_by"), _json_or_none(payload.get("error")), _json_or_none(payload.get("metadata")), ), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() created = self.get_import(import_id) if created is None: raise RuntimeError("advanced material import was inserted but could not be read back") return created def create_style_import_with_sources( self, import_payload: dict[str, Any], source_payloads: list[dict[str, Any]], ) -> tuple[AdvancedMaterialImport, list[AdvancedStyleSource]]: """Atomically persist a 2-8 image style-set draft and all source rows.""" if not 2 <= len(source_payloads) <= 8: raise ValueError("advanced style sets require between two and eight sources") import_id = _payload_id(import_payload, "import_id", "advimp") source_ids = [_payload_id(item, "source_id", "advsrc") for item in source_payloads] sort_orders = [int(item.get("sort_order", index)) for index, item in enumerate(source_payloads)] primary_flags = [bool(item.get("is_primary")) for item in source_payloads] if len(set(source_ids)) != len(source_ids): raise ValueError("advanced style source IDs must be unique") if len(set(sort_orders)) != len(sort_orders): raise ValueError("advanced style source sort orders must be unique") if sum(primary_flags) != 1: raise ValueError("advanced style sets require exactly one primary source") placeholder = self.placeholder conn = self.database.connect() try: if self.database.backend == "sqlite": conn.execute("BEGIN IMMEDIATE") conn.execute( f""" INSERT INTO advanced_material_imports ( import_id, category_id, display_name, source_image_uri, source_thumbnail_uri, status, recognition_prompt, recognition_negative_prompt, recognition_tags_json, recognition_result_json, recognition_model_route, prompt_revision, current_attempt_id, accepted_material_id, idempotency_key, created_by, error_json, metadata_json ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( import_id, import_payload.get("category_id"), str(import_payload["display_name"]), str(import_payload["source_image_uri"]), import_payload.get("source_thumbnail_uri"), import_payload.get("status", "style_source_recognition_queued"), import_payload.get("recognition_prompt"), import_payload.get("recognition_negative_prompt"), _json_or_none(import_payload.get("recognition_tags") or []), _json_or_none(import_payload.get("recognition_result")), import_payload.get("recognition_model_route"), int(import_payload.get("prompt_revision", 0) or 0), import_payload.get("current_attempt_id"), import_payload.get("accepted_material_id"), import_payload.get("idempotency_key"), import_payload.get("created_by"), _json_or_none(import_payload.get("error")), _json_or_none(import_payload.get("metadata")), ), ) for index, source_payload in enumerate(source_payloads): conn.execute( f""" INSERT INTO advanced_style_sources ( source_id, import_id, sort_order, is_primary, source_image_uri, source_thumbnail_uri, status, recognition_model_route, provider_id, provider_model, task_id, recognition_prompt, recognition_negative_prompt, recognition_tags_json, recognition_result_json, error_json, metadata_json, completed_at, excluded_at ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( source_ids[index], import_id, sort_orders[index], 1 if primary_flags[index] else 0, str(source_payload["source_image_uri"]), source_payload.get("source_thumbnail_uri"), source_payload.get("status", "queued"), source_payload.get("recognition_model_route"), source_payload.get("provider_id"), source_payload.get("provider_model"), source_payload.get("task_id"), source_payload.get("recognition_prompt"), source_payload.get("recognition_negative_prompt"), _json_or_none(source_payload.get("recognition_tags") or []), _json_or_none(source_payload.get("recognition_result")), _json_or_none(source_payload.get("error")), _json_or_none(source_payload.get("metadata")), source_payload.get("completed_at"), source_payload.get("excluded_at"), ), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() record = self.get_import(import_id) sources = self.list_style_sources(import_id) if record is None or len(sources) != len(source_payloads): raise RuntimeError("advanced style import was not readable after atomic creation") return record, sources def get_import(self, import_id: str) -> AdvancedMaterialImport | None: conn = self.database.connect() try: row = conn.execute( f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports WHERE import_id = {self.placeholder}", (import_id,), ).fetchone() finally: conn.close() return _row_to_import(row) if row else None def get_import_by_idempotency_key(self, idempotency_key: str) -> AdvancedMaterialImport | None: conn = self.database.connect() try: row = conn.execute( f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports WHERE idempotency_key = {self.placeholder}", (idempotency_key,), ).fetchone() finally: conn.close() return _row_to_import(row) if row else None def update_import(self, import_id: str, payload: dict[str, Any]) -> AdvancedMaterialImport | None: assignments, params = _update_assignments( payload, self.placeholder, { "category_id": "category_id", "display_name": "display_name", "source_image_uri": "source_image_uri", "source_thumbnail_uri": "source_thumbnail_uri", "status": "status", "recognition_prompt": "recognition_prompt", "recognition_negative_prompt": "recognition_negative_prompt", "recognition_tags": "recognition_tags_json", "recognition_result": "recognition_result_json", "recognition_model_route": "recognition_model_route", "prompt_revision": "prompt_revision", "current_attempt_id": "current_attempt_id", "accepted_material_id": "accepted_material_id", "idempotency_key": "idempotency_key", "created_by": "created_by", "error": "error_json", "metadata": "metadata_json", }, ) if not assignments: return self.get_import(import_id) assignments.append("updated_at = CURRENT_TIMESTAMP") params.append(import_id) conn = self.database.connect() try: conn.execute( f"UPDATE advanced_material_imports SET {', '.join(assignments)} WHERE import_id = {self.placeholder}", tuple(params), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() return self.get_import(import_id) def update_import_if_status( self, import_id: str, expected_statuses: set[str] | tuple[str, ...] | list[str], payload: dict[str, Any], ) -> AdvancedMaterialImport | None: """CAS-update an import so cancellation cannot be overwritten.""" statuses = tuple(sorted({str(item).strip() for item in expected_statuses if str(item).strip()})) if not statuses: return None assignments, params = _update_assignments( payload, self.placeholder, { "category_id": "category_id", "display_name": "display_name", "source_image_uri": "source_image_uri", "source_thumbnail_uri": "source_thumbnail_uri", "status": "status", "recognition_prompt": "recognition_prompt", "recognition_negative_prompt": "recognition_negative_prompt", "recognition_tags": "recognition_tags_json", "recognition_result": "recognition_result_json", "recognition_model_route": "recognition_model_route", "prompt_revision": "prompt_revision", "current_attempt_id": "current_attempt_id", "accepted_material_id": "accepted_material_id", "idempotency_key": "idempotency_key", "created_by": "created_by", "error": "error_json", "metadata": "metadata_json", }, ) if not assignments: current = self.get_import(import_id) return current if current and current.status in statuses else None placeholder = self.placeholder assignments.append("updated_at = CURRENT_TIMESTAMP") status_placeholders = ", ".join(placeholder for _ in statuses) params.extend((import_id, *statuses)) conn = self.database.connect() try: cursor = conn.execute( f""" UPDATE advanced_material_imports SET {', '.join(assignments)} WHERE import_id = {placeholder} AND status IN ({status_placeholders}) """, tuple(params), ) changed = int(cursor.rowcount or 0) > 0 conn.commit() except Exception: _rollback(conn) raise finally: conn.close() return self.get_import(import_id) if changed else None def list_imports( self, *, status: str | None = None, category_id: str | None = None, keyword: str | None = None, created_by: str | None = None, page: int = 1, page_size: int = 30, ) -> tuple[list[AdvancedMaterialImport], int]: where: list[str] = [] params: list[Any] = [] placeholder = self.placeholder if status: where.append(f"status = {placeholder}") params.append(status) if category_id: where.append(f"category_id = {placeholder}") params.append(category_id) if created_by: where.append(f"created_by = {placeholder}") params.append(created_by) if keyword: where.append( f"(display_name LIKE {placeholder} OR recognition_prompt LIKE {placeholder})" ) like = f"%{keyword}%" params.extend((like, like)) where_clause = f"WHERE {' AND '.join(where)}" if where else "" normalized_page = _page(page) normalized_page_size = _page_size(page_size) offset = (normalized_page - 1) * normalized_page_size conn = self.database.connect() try: total_row = conn.execute( f"SELECT COUNT(*) AS total FROM advanced_material_imports {where_clause}", tuple(params), ).fetchone() rows = conn.execute( f""" SELECT {IMPORT_COLUMNS} FROM advanced_material_imports {where_clause} ORDER BY created_at DESC, import_id DESC LIMIT {placeholder} OFFSET {placeholder} """, tuple(params + [normalized_page_size, offset]), ).fetchall() finally: conn.close() return [_row_to_import(row) for row in rows], int(total_row["total"] if total_row else 0) def delete_import(self, import_id: str) -> AdvancedMaterialImport | None: """Delete one unsealed import and all of its cascade-owned children.""" placeholder = self.placeholder lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" conn = self.database.connect() try: row = conn.execute( f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports " f"WHERE import_id = {placeholder}{lock}", (import_id,), ).fetchone() if row is None: return None record = _row_to_import(row) material = conn.execute( f"SELECT material_id FROM advanced_materials WHERE import_id = {placeholder}{lock}", (import_id,), ).fetchone() if record.accepted_material_id or material is not None: raise ValueError("accepted advanced material imports cannot be deleted") cursor = conn.execute( f"DELETE FROM advanced_material_imports WHERE import_id = {placeholder}", (import_id,), ) if int(cursor.rowcount or 0) <= 0: _rollback(conn) return None conn.commit() return record except Exception: _rollback(conn) raise finally: conn.close() def create_style_source(self, payload: dict[str, Any]) -> AdvancedStyleSource: source_id = _payload_id(payload, "source_id", "advsrc") placeholder = self.placeholder conn = self.database.connect() try: conn.execute( f""" INSERT INTO advanced_style_sources ( source_id, import_id, sort_order, is_primary, source_image_uri, source_thumbnail_uri, status, recognition_model_route, provider_id, provider_model, task_id, recognition_prompt, recognition_negative_prompt, recognition_tags_json, recognition_result_json, error_json, metadata_json, completed_at, excluded_at ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( source_id, str(payload["import_id"]), int(payload.get("sort_order", 0)), 1 if bool(payload.get("is_primary")) else 0, str(payload["source_image_uri"]), payload.get("source_thumbnail_uri"), payload.get("status", "queued"), payload.get("recognition_model_route"), payload.get("provider_id"), payload.get("provider_model"), payload.get("task_id"), payload.get("recognition_prompt"), payload.get("recognition_negative_prompt"), _json_or_none(payload.get("recognition_tags") or []), _json_or_none(payload.get("recognition_result")), _json_or_none(payload.get("error")), _json_or_none(payload.get("metadata")), payload.get("completed_at"), payload.get("excluded_at"), ), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() created = self.get_style_source(source_id) if created is None: raise RuntimeError("advanced style source was inserted but could not be read back") return created def get_style_source(self, source_id: str) -> AdvancedStyleSource | None: conn = self.database.connect() try: row = conn.execute( f"SELECT {STYLE_SOURCE_COLUMNS} FROM advanced_style_sources " f"WHERE source_id = {self.placeholder}", (source_id,), ).fetchone() finally: conn.close() return _row_to_style_source(row) if row else None def list_style_sources( self, import_id: str, *, include_excluded: bool = True, ) -> list[AdvancedStyleSource]: where = f"import_id = {self.placeholder}" if not include_excluded: where += " AND status <> 'excluded'" conn = self.database.connect() try: rows = conn.execute( f"SELECT {STYLE_SOURCE_COLUMNS} FROM advanced_style_sources " f"WHERE {where} ORDER BY sort_order ASC, source_id ASC", (import_id,), ).fetchall() finally: conn.close() return [_row_to_style_source(row) for row in rows] def update_style_source( self, source_id: str, payload: dict[str, Any], ) -> AdvancedStyleSource | None: assignments, params = _update_assignments( payload, self.placeholder, { "sort_order": "sort_order", "is_primary": "is_primary", "source_image_uri": "source_image_uri", "source_thumbnail_uri": "source_thumbnail_uri", "status": "status", "recognition_model_route": "recognition_model_route", "provider_id": "provider_id", "provider_model": "provider_model", "task_id": "task_id", "recognition_prompt": "recognition_prompt", "recognition_negative_prompt": "recognition_negative_prompt", "recognition_tags": "recognition_tags_json", "recognition_result": "recognition_result_json", "error": "error_json", "metadata": "metadata_json", "completed_at": "completed_at", "excluded_at": "excluded_at", }, ) if not assignments: return self.get_style_source(source_id) status = str(payload.get("status") or "").strip() if status == "succeeded" and "completed_at" not in payload: assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") if status == "excluded" and "excluded_at" not in payload: assignments.append("excluded_at = COALESCE(excluded_at, CURRENT_TIMESTAMP)") assignments.append("updated_at = CURRENT_TIMESTAMP") params.append(source_id) conn = self.database.connect() try: conn.execute( f"UPDATE advanced_style_sources SET {', '.join(assignments)} " f"WHERE source_id = {self.placeholder}", tuple(params), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() return self.get_style_source(source_id) def update_style_source_if_status( self, source_id: str, expected_statuses: set[str] | tuple[str, ...] | list[str], payload: dict[str, Any], ) -> AdvancedStyleSource | None: statuses = tuple(sorted({str(item).strip() for item in expected_statuses if str(item).strip()})) if not statuses: return None assignments, params = _update_assignments( payload, self.placeholder, { "status": "status", "task_id": "task_id", "provider_id": "provider_id", "provider_model": "provider_model", "recognition_prompt": "recognition_prompt", "recognition_negative_prompt": "recognition_negative_prompt", "recognition_tags": "recognition_tags_json", "recognition_result": "recognition_result_json", "error": "error_json", "metadata": "metadata_json", "completed_at": "completed_at", "excluded_at": "excluded_at", }, ) if not assignments: current = self.get_style_source(source_id) return current if current and current.status in statuses else None target_status = str(payload.get("status") or "").strip() if target_status == "succeeded" and "completed_at" not in payload: assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") if target_status == "excluded" and "excluded_at" not in payload: assignments.append("excluded_at = COALESCE(excluded_at, CURRENT_TIMESTAMP)") assignments.append("updated_at = CURRENT_TIMESTAMP") placeholders = ", ".join(self.placeholder for _ in statuses) params.extend((source_id, *statuses)) conn = self.database.connect() try: cursor = conn.execute( f"UPDATE advanced_style_sources SET {', '.join(assignments)} " f"WHERE source_id = {self.placeholder} AND status IN ({placeholders})", tuple(params), ) changed = int(cursor.rowcount or 0) > 0 conn.commit() except Exception: _rollback(conn) raise finally: conn.close() return self.get_style_source(source_id) if changed else None def create_style_consensus_run(self, payload: dict[str, Any]) -> AdvancedStyleConsensusRun: consensus_id = _payload_id(payload, "consensus_id", "advconsensus") placeholder = self.placeholder conn = self.database.connect() try: conn.execute( f""" INSERT INTO advanced_style_consensus_runs ( consensus_id, import_id, revision, status, task_id, model_route, provider_id, provider_model, source_ids_json, prompt, negative_prompt, tags_json, result_json, error_json, metadata_json, completed_at ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( consensus_id, str(payload["import_id"]), int(payload.get("revision", 0)), payload.get("status", "queued"), payload.get("task_id"), payload.get("model_route"), payload.get("provider_id"), payload.get("provider_model"), _json_or_none(payload.get("source_ids") or []), payload.get("prompt"), payload.get("negative_prompt"), _json_or_none(payload.get("tags") or []), _json_or_none(payload.get("result")), _json_or_none(payload.get("error")), _json_or_none(payload.get("metadata")), payload.get("completed_at"), ), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() created = self.get_style_consensus_run(consensus_id) if created is None: raise RuntimeError("advanced style consensus was inserted but could not be read back") return created def get_style_consensus_run(self, consensus_id: str) -> AdvancedStyleConsensusRun | None: conn = self.database.connect() try: row = conn.execute( f"SELECT {STYLE_CONSENSUS_COLUMNS} FROM advanced_style_consensus_runs " f"WHERE consensus_id = {self.placeholder}", (consensus_id,), ).fetchone() finally: conn.close() return _row_to_style_consensus(row) if row else None def get_latest_style_consensus_run(self, import_id: str) -> AdvancedStyleConsensusRun | None: conn = self.database.connect() try: row = conn.execute( f"SELECT {STYLE_CONSENSUS_COLUMNS} FROM advanced_style_consensus_runs " f"WHERE import_id = {self.placeholder} ORDER BY revision DESC, created_at DESC LIMIT 1", (import_id,), ).fetchone() finally: conn.close() return _row_to_style_consensus(row) if row else None def list_style_consensus_runs(self, import_id: str) -> list[AdvancedStyleConsensusRun]: conn = self.database.connect() try: rows = conn.execute( f"SELECT {STYLE_CONSENSUS_COLUMNS} FROM advanced_style_consensus_runs " f"WHERE import_id = {self.placeholder} ORDER BY revision DESC, created_at DESC", (import_id,), ).fetchall() finally: conn.close() return [_row_to_style_consensus(row) for row in rows] def update_style_consensus_run( self, consensus_id: str, payload: dict[str, Any], *, expected_statuses: set[str] | tuple[str, ...] | list[str] | None = None, ) -> AdvancedStyleConsensusRun | None: assignments, params = _update_assignments( payload, self.placeholder, { "status": "status", "task_id": "task_id", "model_route": "model_route", "provider_id": "provider_id", "provider_model": "provider_model", "source_ids": "source_ids_json", "prompt": "prompt", "negative_prompt": "negative_prompt", "tags": "tags_json", "result": "result_json", "error": "error_json", "metadata": "metadata_json", "completed_at": "completed_at", }, ) if not assignments: return self.get_style_consensus_run(consensus_id) status = str(payload.get("status") or "").strip() if status == "succeeded" and "completed_at" not in payload: assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") assignments.append("updated_at = CURRENT_TIMESTAMP") where = f"consensus_id = {self.placeholder}" params.append(consensus_id) statuses = tuple(sorted({str(item).strip() for item in (expected_statuses or ()) if str(item).strip()})) if statuses: where += f" AND status IN ({', '.join(self.placeholder for _ in statuses)})" params.extend(statuses) conn = self.database.connect() try: cursor = conn.execute( f"UPDATE advanced_style_consensus_runs SET {', '.join(assignments)} WHERE {where}", tuple(params), ) changed = int(cursor.rowcount or 0) > 0 conn.commit() except Exception: _rollback(conn) raise finally: conn.close() return self.get_style_consensus_run(consensus_id) if changed else None def create_attempt(self, payload: dict[str, Any]) -> AdvancedMaterialValidationAttempt: attempt_id = _payload_id(payload, "attempt_id", "advattempt") import_id = str(payload["import_id"]) placeholder = self.placeholder conn = self.database.connect() try: if self.database.backend == "sqlite": conn.execute("BEGIN IMMEDIATE") import_row = conn.execute( "SELECT import_id, status, accepted_material_id " f"FROM advanced_material_imports WHERE import_id = {placeholder}" + (" FOR UPDATE" if self.database.backend == "postgresql" else ""), (import_id,), ).fetchone() if import_row is None: raise ValueError("advanced material import does not exist") if str(import_row["status"] or "") in {"accepted", "archived", "cancelled"}: raise ValueError("advanced material import no longer accepts validation attempts") if import_row["accepted_material_id"]: raise ValueError("advanced material import has already been accepted") # Reserve the sequence under the same import lock. Callers may # display a predicted number, but persistence remains the source # of truth so two simultaneous retries cannot claim one round. sequence_row = conn.execute( f""" SELECT COALESCE(MAX(attempt_number), 0) + 1 AS next_number FROM advanced_material_validation_attempts WHERE import_id = {placeholder} """, (import_id,), ).fetchone() attempt_number = int(sequence_row["next_number"] if sequence_row else 1) conn.execute( f""" INSERT INTO advanced_material_validation_attempts ( attempt_id, import_id, attempt_number, status, adjustment_text, prompt, negative_prompt, model_route, provider_id, provider_model, task_id, validation_image_uri, validation_thumbnail_uri, seed, width, height, usage_json, fidelity_score, decision, decision_notes, error_json, metadata_json, completed_at, decided_at ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( attempt_id, import_id, int(attempt_number), payload.get("status", "queued"), payload.get("adjustment_text"), str(payload["prompt"]), payload.get("negative_prompt"), payload.get("model_route"), payload.get("provider_id"), payload.get("provider_model"), payload.get("task_id"), payload.get("validation_image_uri"), payload.get("validation_thumbnail_uri"), _optional_int(payload.get("seed")), _optional_int(payload.get("width")), _optional_int(payload.get("height")), _json_or_none(payload.get("usage")), _optional_float(payload.get("fidelity_score")), payload.get("decision"), payload.get("decision_notes"), _json_or_none(payload.get("error")), _json_or_none(payload.get("metadata")), payload.get("completed_at"), payload.get("decided_at"), ), ) conn.execute( f""" UPDATE advanced_material_imports SET current_attempt_id = {placeholder}, error_json = NULL, updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder} """, (attempt_id, import_id), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() created = self.get_attempt(attempt_id) if created is None: raise RuntimeError("advanced material validation attempt was inserted but could not be read back") return created def create_style_validation_batch( self, attempt_payload: dict[str, Any], case_payloads: list[dict[str, Any]], ) -> tuple[AdvancedMaterialValidationAttempt, list[AdvancedStyleValidationCase]]: """Atomically create one compatibility attempt and its three validation cases.""" if len(case_payloads) != 3: raise ValueError("advanced style validation requires exactly three cases") case_keys = [str(item.get("case_key") or "").strip() for item in case_payloads] if any(not item for item in case_keys) or len(set(case_keys)) != 3: raise ValueError("advanced style validation case keys must be non-empty and unique") attempt_id = _payload_id(attempt_payload, "attempt_id", "advattempt") import_id = str(attempt_payload["import_id"]) placeholder = self.placeholder case_ids: list[str] = [] conn = self.database.connect() try: if self.database.backend == "sqlite": conn.execute("BEGIN IMMEDIATE") lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" import_row = conn.execute( "SELECT import_id, status, accepted_material_id " f"FROM advanced_material_imports WHERE import_id = {placeholder}{lock}", (import_id,), ).fetchone() if import_row is None: raise ValueError("advanced material import does not exist") if str(import_row["status"] or "") in {"accepted", "archived", "cancelled"}: raise ValueError("advanced material import no longer accepts validation attempts") if import_row["accepted_material_id"]: raise ValueError("advanced material import has already been accepted") sequence_row = conn.execute( f"SELECT COALESCE(MAX(attempt_number), 0) + 1 AS next_number " f"FROM advanced_material_validation_attempts WHERE import_id = {placeholder}", (import_id,), ).fetchone() attempt_number = int(sequence_row["next_number"] if sequence_row else 1) conn.execute( f""" INSERT INTO advanced_material_validation_attempts ( attempt_id, import_id, attempt_number, status, adjustment_text, prompt, negative_prompt, model_route, provider_id, provider_model, task_id, validation_image_uri, validation_thumbnail_uri, seed, width, height, usage_json, fidelity_score, decision, decision_notes, error_json, metadata_json, completed_at, decided_at ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( attempt_id, import_id, attempt_number, attempt_payload.get("status", "queued"), attempt_payload.get("adjustment_text"), str(attempt_payload["prompt"]), attempt_payload.get("negative_prompt"), attempt_payload.get("model_route"), attempt_payload.get("provider_id"), attempt_payload.get("provider_model"), attempt_payload.get("task_id"), attempt_payload.get("validation_image_uri"), attempt_payload.get("validation_thumbnail_uri"), _optional_int(attempt_payload.get("seed")), _optional_int(attempt_payload.get("width")), _optional_int(attempt_payload.get("height")), _json_or_none(attempt_payload.get("usage")), _optional_float(attempt_payload.get("fidelity_score")), attempt_payload.get("decision"), attempt_payload.get("decision_notes"), _json_or_none(attempt_payload.get("error")), _json_or_none(attempt_payload.get("metadata")), attempt_payload.get("completed_at"), attempt_payload.get("decided_at"), ), ) for index, case_payload in enumerate(case_payloads): case_id = _payload_id(case_payload, "case_id", "advcase") case_ids.append(case_id) conn.execute( f""" INSERT INTO advanced_style_validation_cases ( case_id, attempt_id, import_id, case_key, sort_order, status, task_id, content_prompt, final_prompt, negative_prompt, model_route, provider_id, provider_model, seed, width, height, validation_image_uri, validation_thumbnail_uri, usage_json, style_review_json, fidelity_score, error_json, metadata_json, completed_at ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( case_id, attempt_id, import_id, case_keys[index], int(case_payload.get("sort_order", index)), case_payload.get("status", "queued"), case_payload.get("task_id"), str(case_payload["content_prompt"]), str(case_payload["final_prompt"]), case_payload.get("negative_prompt"), case_payload.get("model_route") or attempt_payload.get("model_route"), case_payload.get("provider_id"), case_payload.get("provider_model"), _optional_int(case_payload.get("seed")), _optional_int(case_payload.get("width")), _optional_int(case_payload.get("height")), case_payload.get("validation_image_uri"), case_payload.get("validation_thumbnail_uri"), _json_or_none(case_payload.get("usage")), _json_or_none(case_payload.get("style_review")), _optional_float(case_payload.get("fidelity_score")), _json_or_none(case_payload.get("error")), _json_or_none(case_payload.get("metadata")), case_payload.get("completed_at"), ), ) conn.execute( f"UPDATE advanced_material_imports SET current_attempt_id = {placeholder}, " f"error_json = NULL, updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder}", (attempt_id, import_id), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() attempt = self.get_attempt(attempt_id) cases = self.list_style_validation_cases(attempt_id) if attempt is None or len(cases) != 3: raise RuntimeError("advanced style validation batch was not readable after creation") return attempt, cases def get_style_validation_case(self, case_id: str) -> AdvancedStyleValidationCase | None: conn = self.database.connect() try: row = conn.execute( f"SELECT {STYLE_VALIDATION_CASE_COLUMNS} FROM advanced_style_validation_cases " f"WHERE case_id = {self.placeholder}", (case_id,), ).fetchone() finally: conn.close() return _row_to_style_validation_case(row) if row else None def list_style_validation_cases(self, attempt_id: str) -> list[AdvancedStyleValidationCase]: conn = self.database.connect() try: rows = conn.execute( f"SELECT {STYLE_VALIDATION_CASE_COLUMNS} FROM advanced_style_validation_cases " f"WHERE attempt_id = {self.placeholder} ORDER BY sort_order ASC, case_id ASC", (attempt_id,), ).fetchall() finally: conn.close() return [_row_to_style_validation_case(row) for row in rows] def update_style_validation_case( self, case_id: str, payload: dict[str, Any], *, expected_statuses: set[str] | tuple[str, ...] | list[str] | None = None, ) -> AdvancedStyleValidationCase | None: assignments, params = _update_assignments( payload, self.placeholder, { "status": "status", "task_id": "task_id", "content_prompt": "content_prompt", "final_prompt": "final_prompt", "negative_prompt": "negative_prompt", "model_route": "model_route", "provider_id": "provider_id", "provider_model": "provider_model", "seed": "seed", "width": "width", "height": "height", "validation_image_uri": "validation_image_uri", "validation_thumbnail_uri": "validation_thumbnail_uri", "usage": "usage_json", "style_review": "style_review_json", "fidelity_score": "fidelity_score", "error": "error_json", "metadata": "metadata_json", "completed_at": "completed_at", }, ) if not assignments: return self.get_style_validation_case(case_id) status = str(payload.get("status") or "").strip() if status == "succeeded" and "completed_at" not in payload: assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") assignments.append("updated_at = CURRENT_TIMESTAMP") where = f"case_id = {self.placeholder}" params.append(case_id) statuses = tuple(sorted({str(item).strip() for item in (expected_statuses or ()) if str(item).strip()})) if statuses: where += f" AND status IN ({', '.join(self.placeholder for _ in statuses)})" params.extend(statuses) conn = self.database.connect() try: cursor = conn.execute( f"UPDATE advanced_style_validation_cases SET {', '.join(assignments)} WHERE {where}", tuple(params), ) changed = int(cursor.rowcount or 0) > 0 conn.commit() except Exception: _rollback(conn) raise finally: conn.close() return self.get_style_validation_case(case_id) if changed else None def finalize_style_validation_batch_if_ready( self, import_id: str, attempt_id: str, ) -> tuple[AdvancedMaterialImport, AdvancedMaterialValidationAttempt, list[AdvancedStyleValidationCase]]: """Aggregate child cases and publish the compatibility attempt state.""" placeholder = self.placeholder conn = self.database.connect() try: if self.database.backend == "sqlite": conn.execute("BEGIN IMMEDIATE") lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" import_row = conn.execute( f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports " f"WHERE import_id = {placeholder}{lock}", (import_id,), ).fetchone() attempt_row = conn.execute( f"SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts " f"WHERE attempt_id = {placeholder}{lock}", (attempt_id,), ).fetchone() case_rows = conn.execute( f"SELECT {STYLE_VALIDATION_CASE_COLUMNS} FROM advanced_style_validation_cases " f"WHERE attempt_id = {placeholder} ORDER BY sort_order ASC, case_id ASC{lock}", (attempt_id,), ).fetchall() if import_row is None or attempt_row is None or str(attempt_row["import_id"]) != import_id: raise ValueError("advanced style validation batch does not exist") if len(case_rows) != 3: raise ValueError("advanced style validation batch must contain exactly three cases") statuses = [str(row["status"] or "") for row in case_rows] if any(status in {"queued", "running"} for status in statuses): conn.commit() elif all(status == "succeeded" for status in statuses): primary = case_rows[0] metadata = _json_object(attempt_row["metadata_json"]) metadata["style_validation_case_ids"] = [str(row["case_id"]) for row in case_rows] conn.execute( f""" UPDATE advanced_material_validation_attempts SET status = 'awaiting_review', validation_image_uri = {placeholder}, validation_thumbnail_uri = {placeholder}, provider_id = {placeholder}, provider_model = {placeholder}, width = {placeholder}, height = {placeholder}, metadata_json = {placeholder}, error_json = NULL, completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP), updated_at = CURRENT_TIMESTAMP WHERE attempt_id = {placeholder} """, ( primary["validation_image_uri"], primary["validation_thumbnail_uri"], primary["provider_id"], primary["provider_model"], primary["width"], primary["height"], _json_or_none(metadata), attempt_id, ), ) conn.execute( f"UPDATE advanced_material_imports SET status = 'awaiting_review', " f"current_attempt_id = {placeholder}, error_json = NULL, " f"updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder}", (attempt_id, import_id), ) conn.commit() else: failed = [str(row["case_id"]) for row in case_rows if str(row["status"] or "") != "succeeded"] error = {"error_type": "validation_partial_failure", "failed_case_ids": failed} conn.execute( f"UPDATE advanced_material_validation_attempts " f"SET status = 'validation_partial_failed', error_json = {placeholder}, " f"updated_at = CURRENT_TIMESTAMP WHERE attempt_id = {placeholder}", (_json_or_none(error), attempt_id), ) conn.execute( f"UPDATE advanced_material_imports SET status = 'validation_partial_failed', " f"current_attempt_id = {placeholder}, error_json = {placeholder}, " f"updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder}", (attempt_id, _json_or_none(error), import_id), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() record = self.get_import(import_id) attempt = self.get_attempt(attempt_id) cases = self.list_style_validation_cases(attempt_id) if record is None or attempt is None: raise RuntimeError("advanced style validation batch disappeared after aggregation") return record, attempt, cases def get_attempt(self, attempt_id: str) -> AdvancedMaterialValidationAttempt | None: conn = self.database.connect() try: row = conn.execute( f"SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts " f"WHERE attempt_id = {self.placeholder}", (attempt_id,), ).fetchone() finally: conn.close() return _row_to_attempt(row) if row else None def update_attempt( self, attempt_id: str, payload: dict[str, Any], ) -> AdvancedMaterialValidationAttempt | None: assignments, params = _update_assignments( payload, self.placeholder, { "status": "status", "adjustment_text": "adjustment_text", "prompt": "prompt", "negative_prompt": "negative_prompt", "model_route": "model_route", "provider_id": "provider_id", "provider_model": "provider_model", "task_id": "task_id", "validation_image_uri": "validation_image_uri", "validation_thumbnail_uri": "validation_thumbnail_uri", "seed": "seed", "width": "width", "height": "height", "usage": "usage_json", "fidelity_score": "fidelity_score", "decision": "decision", "decision_notes": "decision_notes", "error": "error_json", "metadata": "metadata_json", "completed_at": "completed_at", "decided_at": "decided_at", }, ) if not assignments: return self.get_attempt(attempt_id) target_status = str(payload.get("status") or "").strip() if ( target_status in {"awaiting_review", "succeeded", "completed"} and "completed_at" not in payload ): assignments.append("completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)") if target_status in {"accepted", "rejected", "cancelled"} and "decided_at" not in payload: assignments.append("decided_at = COALESCE(decided_at, CURRENT_TIMESTAMP)") assignments.append("updated_at = CURRENT_TIMESTAMP") params.append(attempt_id) conn = self.database.connect() try: conn.execute( "UPDATE advanced_material_validation_attempts " f"SET {', '.join(assignments)} WHERE attempt_id = {self.placeholder}", tuple(params), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() return self.get_attempt(attempt_id) def list_attempts(self, import_id: str) -> list[AdvancedMaterialValidationAttempt]: conn = self.database.connect() try: rows = conn.execute( f""" SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts WHERE import_id = {self.placeholder} ORDER BY attempt_number DESC, created_at DESC """, (import_id,), ).fetchall() finally: conn.close() return [_row_to_attempt(row) for row in rows] def get_active_attempt(self, import_id: str) -> AdvancedMaterialValidationAttempt | None: conn = self.database.connect() try: row = conn.execute( f""" SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts WHERE import_id = {self.placeholder} AND status IN ('queued', 'running') ORDER BY attempt_number DESC LIMIT 1 """, (import_id,), ).fetchone() finally: conn.close() return _row_to_attempt(row) if row else None def mark_attempt_running( self, import_id: str, attempt_id: str, ) -> tuple[AdvancedMaterialImport, AdvancedMaterialValidationAttempt] | None: """Atomically enter provider execution unless the import was cancelled.""" placeholder = self.placeholder conn = self.database.connect() try: if self.database.backend == "sqlite": conn.execute("BEGIN IMMEDIATE") lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" import_row = conn.execute( f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports WHERE import_id = {placeholder}{lock}", (import_id,), ).fetchone() attempt_row = conn.execute( f"SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts WHERE attempt_id = {placeholder}{lock}", (attempt_id,), ).fetchone() if import_row is None or attempt_row is None or str(attempt_row["import_id"]) != import_id: conn.commit() return None import_status = str(import_row["status"] or "") attempt_status = str(attempt_row["status"] or "") if import_status == "validating" and attempt_status == "running": conn.commit() return _row_to_import(import_row), _row_to_attempt(attempt_row) if ( import_status != "validation_queued" or attempt_status != "queued" or str(import_row["current_attempt_id"] or "") != attempt_id ): conn.commit() return None conn.execute( f"UPDATE advanced_material_validation_attempts SET status = 'running', error_json = NULL, updated_at = CURRENT_TIMESTAMP WHERE attempt_id = {placeholder}", (attempt_id,), ) conn.execute( f"UPDATE advanced_material_imports SET status = 'validating', error_json = NULL, updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder}", (import_id,), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() current_import = self.get_import(import_id) current_attempt = self.get_attempt(attempt_id) if current_import is None or current_attempt is None: return None return current_import, current_attempt def complete_attempt_if_active( self, import_id: str, attempt_id: str, *, attempt_payload: dict[str, Any], import_payload: dict[str, Any], ) -> tuple[AdvancedMaterialImport, AdvancedMaterialValidationAttempt] | None: """Atomically publish a validation result only while it still owns the import.""" placeholder = self.placeholder conn = self.database.connect() try: if self.database.backend == "sqlite": conn.execute("BEGIN IMMEDIATE") lock = " FOR UPDATE" if self.database.backend == "postgresql" else "" import_row = conn.execute( f"SELECT status, current_attempt_id FROM advanced_material_imports WHERE import_id = {placeholder}{lock}", (import_id,), ).fetchone() attempt_row = conn.execute( f"SELECT status, import_id FROM advanced_material_validation_attempts WHERE attempt_id = {placeholder}{lock}", (attempt_id,), ).fetchone() if ( import_row is None or attempt_row is None or str(attempt_row["import_id"] or "") != import_id or str(import_row["current_attempt_id"] or "") != attempt_id or str(import_row["status"] or "") != "validating" or str(attempt_row["status"] or "") != "running" ): conn.commit() return None attempt_assignments, attempt_params = _update_assignments( {**attempt_payload, "status": "awaiting_review", "error": None}, placeholder, { "status": "status", "model_route": "model_route", "provider_id": "provider_id", "provider_model": "provider_model", "validation_image_uri": "validation_image_uri", "validation_thumbnail_uri": "validation_thumbnail_uri", "width": "width", "height": "height", "usage": "usage_json", "error": "error_json", "metadata": "metadata_json", }, ) attempt_assignments.extend(( "completed_at = COALESCE(completed_at, CURRENT_TIMESTAMP)", "updated_at = CURRENT_TIMESTAMP", )) attempt_params.append(attempt_id) conn.execute( f"UPDATE advanced_material_validation_attempts SET {', '.join(attempt_assignments)} WHERE attempt_id = {placeholder}", tuple(attempt_params), ) import_assignments, import_params = _update_assignments( {**import_payload, "status": "awaiting_review", "current_attempt_id": attempt_id, "error": None}, placeholder, { "status": "status", "current_attempt_id": "current_attempt_id", "error": "error_json", "metadata": "metadata_json", }, ) import_assignments.append("updated_at = CURRENT_TIMESTAMP") import_params.append(import_id) conn.execute( f"UPDATE advanced_material_imports SET {', '.join(import_assignments)} WHERE import_id = {placeholder}", tuple(import_params), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() current_import = self.get_import(import_id) current_attempt = self.get_attempt(attempt_id) if current_import is None or current_attempt is None: return None return current_import, current_attempt def create_material(self, payload: dict[str, Any]) -> AdvancedMaterial: material_id = _payload_id(payload, "material_id", "advmat") placeholder = self.placeholder conn = self.database.connect() try: _insert_material(conn, placeholder, material_id, payload) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() created = self.get_material(material_id) if created is None: raise RuntimeError("advanced material was inserted but could not be read back") return created def get_material(self, material_id: str) -> AdvancedMaterial | None: conn = self.database.connect() try: row = conn.execute( f"SELECT {MATERIAL_COLUMNS} FROM advanced_materials WHERE material_id = {self.placeholder}", (material_id,), ).fetchone() finally: conn.close() return _row_to_material(row) if row else None def get_material_by_import(self, import_id: str) -> AdvancedMaterial | None: conn = self.database.connect() try: row = conn.execute( f"SELECT {MATERIAL_COLUMNS} FROM advanced_materials WHERE import_id = {self.placeholder}", (import_id,), ).fetchone() finally: conn.close() return _row_to_material(row) if row else None def list_materials( self, *, category_id: str | None = None, status: str | None = "active", keyword: str | None = None, page: int = 1, page_size: int = 30, ) -> tuple[list[AdvancedMaterial], int]: where: list[str] = [] params: list[Any] = [] placeholder = self.placeholder if status: where.append(f"status = {placeholder}") params.append(status) if category_id: where.append(f"category_id = {placeholder}") params.append(category_id) if keyword: where.append(f"(display_name LIKE {placeholder} OR prompt LIKE {placeholder})") like = f"%{keyword}%" params.extend((like, like)) where_clause = f"WHERE {' AND '.join(where)}" if where else "" normalized_page = _page(page) normalized_page_size = _page_size(page_size) offset = (normalized_page - 1) * normalized_page_size conn = self.database.connect() try: total_row = conn.execute( f"SELECT COUNT(*) AS total FROM advanced_materials {where_clause}", tuple(params), ).fetchone() rows = conn.execute( f""" SELECT {MATERIAL_COLUMNS} FROM advanced_materials {where_clause} ORDER BY priority DESC, accepted_at DESC, material_id DESC LIMIT {placeholder} OFFSET {placeholder} """, tuple(params + [normalized_page_size, offset]), ).fetchall() finally: conn.close() return [_row_to_material(row) for row in rows], int(total_row["total"] if total_row else 0) def update_material(self, material_id: str, payload: dict[str, Any]) -> AdvancedMaterial | None: assignments, params = _update_assignments( payload, self.placeholder, { "category_id": "category_id", "display_name": "display_name", "source_image_uri": "source_image_uri", "source_thumbnail_uri": "source_thumbnail_uri", "validation_image_uri": "validation_image_uri", "validation_thumbnail_uri": "validation_thumbnail_uri", "prompt": "prompt", "negative_prompt": "negative_prompt", "tags": "tags_json", "priority": "priority", "status": "status", "capsule": "capsule_json", "metadata": "metadata_json", "accepted_at": "accepted_at", "archived_at": "archived_at", }, ) if not assignments: return self.get_material(material_id) assignments.append("updated_at = CURRENT_TIMESTAMP") params.append(material_id) conn = self.database.connect() try: conn.execute( f"UPDATE advanced_materials SET {', '.join(assignments)} WHERE material_id = {self.placeholder}", tuple(params), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() return self.get_material(material_id) def archive_material(self, material_id: str) -> AdvancedMaterial | None: conn = self.database.connect() try: conn.execute( f""" UPDATE advanced_materials SET status = 'archived', archived_at = COALESCE(archived_at, CURRENT_TIMESTAMP), updated_at = CURRENT_TIMESTAMP WHERE material_id = {self.placeholder} """, (material_id,), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() return self.get_material(material_id) def accept_attempt( self, import_id: str, attempt_id: str, payload: dict[str, Any], ) -> AdvancedMaterial: """Atomically seal one successful validation attempt into the high-priority catalog.""" placeholder = self.placeholder conn = self.database.connect() try: if self.database.backend == "sqlite": conn.execute("BEGIN IMMEDIATE") lock_suffix = " FOR UPDATE" if self.database.backend == "postgresql" else "" import_row = conn.execute( f"SELECT {IMPORT_COLUMNS} FROM advanced_material_imports WHERE import_id = {placeholder}{lock_suffix}", (import_id,), ).fetchone() if import_row is None: raise ValueError("advanced material import does not exist") attempt_row = conn.execute( f"SELECT {ATTEMPT_COLUMNS} FROM advanced_material_validation_attempts " f"WHERE attempt_id = {placeholder}{lock_suffix}", (attempt_id,), ).fetchone() if attempt_row is None: raise ValueError("advanced material validation attempt does not exist") if str(attempt_row["import_id"]) != str(import_id): raise ValueError("validation attempt belongs to another advanced material import") current_attempt_id = _optional_text(import_row["current_attempt_id"]) if current_attempt_id and current_attempt_id != attempt_id: raise ValueError("only the current validation attempt can be accepted") existing_row = conn.execute( f"SELECT {MATERIAL_COLUMNS} FROM advanced_materials WHERE import_id = {placeholder}", (import_id,), ).fetchone() if existing_row is not None: existing = _row_to_material(existing_row) if existing.accepted_attempt_id != attempt_id: raise ValueError("advanced material import has already accepted another attempt") conn.commit() return existing if import_row["accepted_material_id"]: raise ValueError("advanced material import points to a missing accepted material") style_case_rows = conn.execute( f"SELECT status FROM advanced_style_validation_cases " f"WHERE attempt_id = {placeholder}{lock_suffix}", (attempt_id,), ).fetchall() if style_case_rows and ( len(style_case_rows) != 3 or any(str(row["status"] or "") != "succeeded" for row in style_case_rows) ): raise ValueError("all three advanced style validation cases must succeed before acceptance") attempt_status = str(attempt_row["status"] or "") if attempt_status not in {"awaiting_review", "succeeded", "completed", "accepted"}: raise ValueError("only a completed validation attempt can be accepted") validation_image_uri = payload.get("validation_image_uri") or attempt_row["validation_image_uri"] if not validation_image_uri: raise ValueError("validation attempt does not have a generated verification image") material_id = _payload_id(payload, "material_id", "advmat") insert_payload = { "import_id": import_id, "accepted_attempt_id": attempt_id, "category_id": payload.get("category_id", import_row["category_id"]), "display_name": payload.get("display_name", import_row["display_name"]), "source_image_uri": payload.get("source_image_uri", import_row["source_image_uri"]), "source_thumbnail_uri": payload.get( "source_thumbnail_uri", import_row["source_thumbnail_uri"] ), "validation_image_uri": validation_image_uri, "validation_thumbnail_uri": payload.get("validation_thumbnail_uri") or attempt_row["validation_thumbnail_uri"], "prompt": payload.get("prompt") or attempt_row["prompt"] or import_row["recognition_prompt"], "negative_prompt": payload.get("negative_prompt") if "negative_prompt" in payload else attempt_row["negative_prompt"] or import_row["recognition_negative_prompt"], "tags": payload.get("tags") if "tags" in payload else _json_list(import_row["recognition_tags_json"]), "priority": payload.get("priority", 100), "status": payload.get("status", "active"), "capsule": payload.get("capsule"), "metadata": payload.get("metadata"), "accepted_at": payload.get("accepted_at"), } if not insert_payload["prompt"]: raise ValueError("accepted advanced material requires a reusable prompt") _insert_material(conn, placeholder, material_id, insert_payload) conn.execute( f""" UPDATE advanced_material_validation_attempts SET status = 'accepted', decision = 'accepted', decision_notes = {placeholder}, decided_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP WHERE attempt_id = {placeholder} """, (payload.get("decision_notes"), attempt_id), ) conn.execute( f""" UPDATE advanced_material_imports SET status = 'accepted', current_attempt_id = {placeholder}, accepted_material_id = {placeholder}, error_json = NULL, updated_at = CURRENT_TIMESTAMP WHERE import_id = {placeholder} """, (attempt_id, material_id, import_id), ) conn.commit() except Exception: _rollback(conn) raise finally: conn.close() accepted = self.get_material(material_id) if accepted is None: raise RuntimeError("accepted advanced material was not readable after transaction") return accepted def _insert_material( conn, placeholder: str, material_id: str, payload: dict[str, Any], ) -> None: conn.execute( f""" INSERT INTO advanced_materials ( material_id, import_id, accepted_attempt_id, category_id, display_name, source_image_uri, source_thumbnail_uri, validation_image_uri, validation_thumbnail_uri, prompt, negative_prompt, tags_json, priority, status, capsule_json, metadata_json, accepted_at, archived_at ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, COALESCE({placeholder}, CURRENT_TIMESTAMP), {placeholder} ) """, ( material_id, payload["import_id"], payload["accepted_attempt_id"], payload.get("category_id"), str(payload["display_name"]), str(payload["source_image_uri"]), payload.get("source_thumbnail_uri"), str(payload["validation_image_uri"]), payload.get("validation_thumbnail_uri"), str(payload["prompt"]), payload.get("negative_prompt"), _json_or_none(payload.get("tags") or []), int(payload.get("priority", 100) or 100), payload.get("status", "active"), _json_or_none(payload.get("capsule")), _json_or_none(payload.get("metadata")), payload.get("accepted_at"), payload.get("archived_at"), ), ) def _row_to_import(row) -> AdvancedMaterialImport: return AdvancedMaterialImport( import_id=str(row["import_id"]), category_id=_optional_text(row["category_id"]), display_name=str(row["display_name"]), source_image_uri=str(row["source_image_uri"]), source_thumbnail_uri=_optional_text(row["source_thumbnail_uri"]), status=str(row["status"]), recognition_prompt=_optional_text(row["recognition_prompt"]), recognition_negative_prompt=_optional_text(row["recognition_negative_prompt"]), recognition_tags=_json_list(row["recognition_tags_json"]), recognition_result=_json_object(row["recognition_result_json"]), recognition_model_route=_optional_text(row["recognition_model_route"]), prompt_revision=int(row["prompt_revision"] or 0), current_attempt_id=_optional_text(row["current_attempt_id"]), accepted_material_id=_optional_text(row["accepted_material_id"]), idempotency_key=_optional_text(row["idempotency_key"]), created_by=_optional_text(row["created_by"]), error=_json_object(row["error_json"]), metadata=_json_object(row["metadata_json"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), ) def _row_to_attempt(row) -> AdvancedMaterialValidationAttempt: return AdvancedMaterialValidationAttempt( attempt_id=str(row["attempt_id"]), import_id=str(row["import_id"]), attempt_number=int(row["attempt_number"] or 0), status=str(row["status"]), adjustment_text=_optional_text(row["adjustment_text"]), prompt=str(row["prompt"] or ""), negative_prompt=_optional_text(row["negative_prompt"]), model_route=_optional_text(row["model_route"]), provider_id=_optional_text(row["provider_id"]), provider_model=_optional_text(row["provider_model"]), task_id=_optional_text(row["task_id"]), validation_image_uri=_optional_text(row["validation_image_uri"]), validation_thumbnail_uri=_optional_text(row["validation_thumbnail_uri"]), seed=_optional_int(row["seed"]), width=_optional_int(row["width"]), height=_optional_int(row["height"]), usage=_json_object(row["usage_json"]), fidelity_score=_optional_float(row["fidelity_score"]), decision=_optional_text(row["decision"]), decision_notes=_optional_text(row["decision_notes"]), error=_json_object(row["error_json"]), metadata=_json_object(row["metadata_json"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), completed_at=_optional_text(row["completed_at"]), decided_at=_optional_text(row["decided_at"]), ) def _row_to_material(row) -> AdvancedMaterial: return AdvancedMaterial( material_id=str(row["material_id"]), import_id=str(row["import_id"]), accepted_attempt_id=str(row["accepted_attempt_id"]), category_id=_optional_text(row["category_id"]), display_name=str(row["display_name"]), source_image_uri=str(row["source_image_uri"]), source_thumbnail_uri=_optional_text(row["source_thumbnail_uri"]), validation_image_uri=str(row["validation_image_uri"]), validation_thumbnail_uri=_optional_text(row["validation_thumbnail_uri"]), prompt=str(row["prompt"]), negative_prompt=_optional_text(row["negative_prompt"]), tags=_json_list(row["tags_json"]), priority=int(row["priority"] or 0), status=str(row["status"]), capsule=_json_object(row["capsule_json"]), metadata=_json_object(row["metadata_json"]), accepted_at=str(row["accepted_at"]), archived_at=_optional_text(row["archived_at"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), ) def _row_to_style_source(row) -> AdvancedStyleSource: return AdvancedStyleSource( source_id=str(row["source_id"]), import_id=str(row["import_id"]), sort_order=int(row["sort_order"] or 0), is_primary=bool(row["is_primary"]), source_image_uri=str(row["source_image_uri"]), source_thumbnail_uri=_optional_text(row["source_thumbnail_uri"]), status=str(row["status"]), recognition_model_route=_optional_text(row["recognition_model_route"]), provider_id=_optional_text(row["provider_id"]), provider_model=_optional_text(row["provider_model"]), task_id=_optional_text(row["task_id"]), recognition_prompt=_optional_text(row["recognition_prompt"]), recognition_negative_prompt=_optional_text(row["recognition_negative_prompt"]), recognition_tags=_json_list(row["recognition_tags_json"]), recognition_result=_json_object(row["recognition_result_json"]), error=_json_object(row["error_json"]), metadata=_json_object(row["metadata_json"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), completed_at=_optional_text(row["completed_at"]), excluded_at=_optional_text(row["excluded_at"]), ) def _row_to_style_consensus(row) -> AdvancedStyleConsensusRun: return AdvancedStyleConsensusRun( consensus_id=str(row["consensus_id"]), import_id=str(row["import_id"]), revision=int(row["revision"] or 0), status=str(row["status"]), task_id=_optional_text(row["task_id"]), model_route=_optional_text(row["model_route"]), provider_id=_optional_text(row["provider_id"]), provider_model=_optional_text(row["provider_model"]), source_ids=_json_list(row["source_ids_json"]), prompt=_optional_text(row["prompt"]), negative_prompt=_optional_text(row["negative_prompt"]), tags=_json_list(row["tags_json"]), result=_json_object(row["result_json"]), error=_json_object(row["error_json"]), metadata=_json_object(row["metadata_json"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), completed_at=_optional_text(row["completed_at"]), ) def _row_to_style_validation_case(row) -> AdvancedStyleValidationCase: return AdvancedStyleValidationCase( case_id=str(row["case_id"]), attempt_id=str(row["attempt_id"]), import_id=str(row["import_id"]), case_key=str(row["case_key"]), sort_order=int(row["sort_order"] or 0), status=str(row["status"]), task_id=_optional_text(row["task_id"]), content_prompt=str(row["content_prompt"] or ""), final_prompt=str(row["final_prompt"] or ""), negative_prompt=_optional_text(row["negative_prompt"]), model_route=_optional_text(row["model_route"]), provider_id=_optional_text(row["provider_id"]), provider_model=_optional_text(row["provider_model"]), seed=_optional_int(row["seed"]), width=_optional_int(row["width"]), height=_optional_int(row["height"]), validation_image_uri=_optional_text(row["validation_image_uri"]), validation_thumbnail_uri=_optional_text(row["validation_thumbnail_uri"]), usage=_json_object(row["usage_json"]), style_review=_json_object(row["style_review_json"]), fidelity_score=_optional_float(row["fidelity_score"]), error=_json_object(row["error_json"]), metadata=_json_object(row["metadata_json"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), completed_at=_optional_text(row["completed_at"]), ) def _update_assignments( payload: dict[str, Any], placeholder: str, columns: dict[str, str], ) -> tuple[list[str], list[Any]]: assignments: list[str] = [] params: list[Any] = [] for key, column in columns.items(): if key not in payload: continue value = payload[key] if column.endswith("_json"): value = _json_or_none(value) elif key in { "prompt_revision", "priority", "seed", "width", "height", "sort_order", "revision", "is_primary", }: value = _optional_int(value) elif key == "fidelity_score": value = _optional_float(value) assignments.append(f"{column} = {placeholder}") params.append(value) return assignments, params def _payload_id(payload: dict[str, Any], key: str, prefix: str) -> str: value = str(payload.get(key) or "").strip() return value or f"{prefix}_{uuid4().hex}" def _json_or_none(value: Any | None) -> str | None: if value is None: return None return json.dumps(value, ensure_ascii=False, sort_keys=True) def _json_object(value: str | None) -> dict[str, Any]: if not value: return {} parsed = json.loads(value) return parsed if isinstance(parsed, dict) else {} def _json_list(value: str | None) -> list[str]: if not value: return [] parsed = json.loads(value) return [str(item) for item in parsed] if isinstance(parsed, list) else [] def _optional_text(value: Any) -> str | None: if value is None: return None text = str(value).strip() return text or None def _optional_int(value: Any) -> int | None: if value in (None, ""): return None return int(value) def _optional_float(value: Any) -> float | None: if value in (None, ""): return None return float(value) def _page(value: int) -> int: return max(int(value or 1), 1) def _page_size(value: int) -> int: return min(max(int(value or 30), 1), 200) def _rollback(conn) -> None: try: conn.rollback() except Exception: return