2119 行
89 KiB
Python
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
|