"""Repository for generation tasks and queue status.""" from __future__ import annotations import json from typing import Any from backend.dto.job_dto import GenerationTask from database.db_helper import Database TASK_COLUMNS = """ task_id, profile_id, workflow_id, node_id, task_type, status, model_route, progress, idempotency_key, request_json, result_json, error_message, metadata_json, created_at, updated_at """ class JobRepository: def __init__(self, database: Database): self.database = database @property def placeholder(self) -> str: return self.database._placeholder def create(self, payload: dict[str, Any]) -> GenerationTask: placeholder = self.placeholder conn = self.database.connect() try: conn.execute( f""" INSERT INTO generation_tasks ( task_id, profile_id, workflow_id, node_id, task_type, status, model_route, progress, idempotency_key, request_json, result_json, error_message, metadata_json ) VALUES ( {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder} ) """, ( payload["task_id"], payload.get("profile_id"), payload.get("workflow_id"), payload.get("node_id"), payload.get("task_type", "generation"), payload.get("status", "created"), payload.get("model_route"), int(payload.get("progress", 0)), payload.get("idempotency_key"), _json_or_none(payload.get("request")), _json_or_none(payload.get("result")), payload.get("error_message"), _json_or_none(payload.get("metadata")), ), ) conn.commit() finally: conn.close() task = self.get(payload["task_id"]) if task is None: raise RuntimeError("generation task was inserted but could not be read back") return task def get(self, task_id: str) -> GenerationTask | None: placeholder = self.placeholder conn = self.database.connect() try: row = conn.execute( f"SELECT {TASK_COLUMNS} FROM generation_tasks WHERE task_id = {placeholder}", (task_id,), ).fetchone() finally: conn.close() return _row_to_task(row) if row else None def get_by_idempotency_key(self, idempotency_key: str) -> GenerationTask | None: placeholder = self.placeholder conn = self.database.connect() try: row = conn.execute( f"SELECT {TASK_COLUMNS} FROM generation_tasks WHERE idempotency_key = {placeholder}", (idempotency_key,), ).fetchone() finally: conn.close() return _row_to_task(row) if row else None def list( self, *, status: str | None = None, workflow_id: str | None = None, profile_id: str | None = None, page: int = 1, page_size: int = 30, ) -> tuple[list[GenerationTask], int]: placeholder = self.placeholder where: list[str] = [] params: list[Any] = [] if status: where.append(f"status = {placeholder}") params.append(status) if workflow_id: where.append(f"workflow_id = {placeholder}") params.append(workflow_id) if profile_id: where.append(f"profile_id = {placeholder}") params.append(profile_id) 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 generation_tasks {where_clause}", tuple(params), ).fetchone() rows = conn.execute( f""" SELECT {TASK_COLUMNS} FROM generation_tasks {where_clause} ORDER BY created_at DESC LIMIT {placeholder} OFFSET {placeholder} """, tuple(params + [normalized_page_size, offset]), ).fetchall() finally: conn.close() return [_row_to_task(row) for row in rows], int(total_row["total"] if total_row else 0) def update(self, task_id: str, payload: dict[str, Any]) -> GenerationTask | None: allowed = { "status", "model_route", "progress", "request", "result", "error_message", "metadata", } assignments: list[str] = [] params: list[Any] = [] placeholder = self.placeholder for key in allowed: if key not in payload: continue column = key value = payload[key] if key == "request": column = "request_json" value = _json_or_none(value) elif key == "result": column = "result_json" value = _json_or_none(value) elif key == "metadata": column = "metadata_json" value = _json_or_none(value) elif key == "progress": value = int(value) assignments.append(f"{column} = {placeholder}") params.append(value) if not assignments: return self.get(task_id) assignments.append("updated_at = CURRENT_TIMESTAMP") params.append(task_id) conn = self.database.connect() try: conn.execute( f""" UPDATE generation_tasks SET {", ".join(assignments)} WHERE task_id = {placeholder} """, tuple(params), ) conn.commit() finally: conn.close() return self.get(task_id) def count_by_status(self) -> dict[str, int]: conn = self.database.connect() try: rows = conn.execute( """ SELECT status, COUNT(*) AS total FROM generation_tasks GROUP BY status """ ).fetchall() finally: conn.close() return {row["status"]: int(row["total"]) for row in rows} def recent(self, limit: int = 10) -> list[GenerationTask]: placeholder = self.placeholder conn = self.database.connect() try: rows = conn.execute( f""" SELECT {TASK_COLUMNS} FROM generation_tasks ORDER BY created_at DESC LIMIT {placeholder} """, (_limit(limit),), ).fetchall() finally: conn.close() return [_row_to_task(row) for row in rows] def _row_to_task(row) -> GenerationTask: return GenerationTask( task_id=row["task_id"], profile_id=row["profile_id"], workflow_id=row["workflow_id"], node_id=row["node_id"], task_type=row["task_type"], status=row["status"], model_route=row["model_route"], progress=int(row["progress"] or 0), idempotency_key=row["idempotency_key"], request=_json_loads(row["request_json"]), result=_json_loads(row["result_json"]), error_message=row["error_message"], metadata=_json_loads(row["metadata_json"]), created_at=str(row["created_at"]), updated_at=str(row["updated_at"]), ) 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 _limit(value: int) -> int: try: limit = int(value) except (TypeError, ValueError): limit = 10 return min(max(limit, 1), 100) def _page(value: Any) -> int: try: page = int(value) except (TypeError, ValueError): page = 1 return max(page, 1) def _page_size(value: Any) -> int: try: page_size = int(value) except (TypeError, ValueError): page_size = 30 return min(max(page_size, 1), 100) def _json_loads(value: str | None) -> dict[str, Any]: if not value: return {} return json.loads(value)