astrbot_plugin_imagestudio/database/repositories/advanced_material_repository.py

2119 行
89 KiB
Python

"""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
from core.text_utils import optional_text as _optional_text
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_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