modularize service layer, add mobile nav drawer, and sync docs

app/services/domains/runs/queue_service.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from sqlalchemy import case, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models import IngestionQueueItem
+from app.services.domains.ingestion import queue as queue_mutations
+from app.services.domains.runs.queue_queries import queue_item_select, queue_list_item_from_row
+from app.services.domains.runs.types import (
+    QUEUE_STATUS_DROPPED,
+    QUEUE_STATUS_QUEUED,
+    QUEUE_STATUS_RETRYING,
+    QueueClearResult,
+    QueueListItem,
+    QueueTransitionError,
+)
+
+
+async def list_queue_items_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    limit: int = 200,
+) -> list[QueueListItem]:
+    result = await db_session.execute(
+        queue_item_select(user_id=user_id)
+        .order_by(
+            case((IngestionQueueItem.status == QUEUE_STATUS_DROPPED, 1), else_=0).asc(),
+            IngestionQueueItem.next_attempt_dt.asc(),
+            IngestionQueueItem.id.asc(),
+        )
+        .limit(limit)
+    )
+    return [queue_list_item_from_row(row) for row in result.all()]
+
+
+async def get_queue_item_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    queue_item_id: int,
+) -> QueueListItem | None:
+    result = await db_session.execute(
+        queue_item_select(user_id=user_id)
+        .where(IngestionQueueItem.id == queue_item_id)
+        .limit(1)
+    )
+    row = result.one_or_none()
+    if row is None:
+        return None
+    return queue_list_item_from_row(row)
+
+
+async def retry_queue_item_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    queue_item_id: int,
+) -> QueueListItem | None:
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(
+            IngestionQueueItem.id == queue_item_id,
+            IngestionQueueItem.user_id == user_id,
+        )
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    if item.status == QUEUE_STATUS_QUEUED:
+        raise QueueTransitionError(
+            code="queue_item_already_queued",
+            message="Queue item is already queued.",
+            current_status=item.status,
+        )
+    if item.status == QUEUE_STATUS_RETRYING:
+        raise QueueTransitionError(
+            code="queue_item_retrying",
+            message="Queue item is currently retrying.",
+            current_status=item.status,
+        )
+
+    await queue_mutations.mark_queued_now(
+        db_session,
+        job_id=item.id,
+        reason="manual_retry",
+        reset_attempt_count=(item.status == QUEUE_STATUS_DROPPED),
+    )
+    await db_session.commit()
+    return await get_queue_item_for_user(
+        db_session,
+        user_id=user_id,
+        queue_item_id=queue_item_id,
+    )
+
+
+async def drop_queue_item_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    queue_item_id: int,
+) -> QueueListItem | None:
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(
+            IngestionQueueItem.id == queue_item_id,
+            IngestionQueueItem.user_id == user_id,
+        )
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    if item.status == QUEUE_STATUS_DROPPED:
+        raise QueueTransitionError(
+            code="queue_item_already_dropped",
+            message="Queue item is already dropped.",
+            current_status=item.status,
+        )
+
+    await queue_mutations.mark_dropped(
+        db_session,
+        job_id=int(item.id),
+        reason="manual_drop",
+    )
+    await db_session.commit()
+    return await get_queue_item_for_user(
+        db_session,
+        user_id=user_id,
+        queue_item_id=queue_item_id,
+    )
+
+
+async def clear_queue_item_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+    queue_item_id: int,
+) -> QueueClearResult | None:
+    result = await db_session.execute(
+        select(IngestionQueueItem).where(
+            IngestionQueueItem.id == queue_item_id,
+            IngestionQueueItem.user_id == user_id,
+        )
+    )
+    item = result.scalar_one_or_none()
+    if item is None:
+        return None
+    if item.status != QUEUE_STATUS_DROPPED:
+        raise QueueTransitionError(
+            code="queue_item_not_dropped",
+            message="Queue item can only be cleared after it is dropped.",
+            current_status=item.status,
+        )
+
+    item_id = int(item.id)
+    previous_status = str(item.status)
+    deleted = await queue_mutations.delete_job_by_id(db_session, job_id=item_id)
+    await db_session.commit()
+    if not deleted:
+        return None
+    return QueueClearResult(queue_item_id=item_id, previous_status=previous_status)
+
+
+async def queue_status_counts_for_user(
+    db_session: AsyncSession,
+    *,
+    user_id: int,
+) -> dict[str, int]:
+    result = await db_session.execute(
+        select(
+            IngestionQueueItem.status,
+            func.count(IngestionQueueItem.id),
+        )
+        .where(IngestionQueueItem.user_id == user_id)
+        .group_by(IngestionQueueItem.status)
+    )
+    counts: dict[str, int] = {
+        QUEUE_STATUS_QUEUED: 0,
+        QUEUE_STATUS_RETRYING: 0,
+        QUEUE_STATUS_DROPPED: 0,
+    }
+    for status, count in result.all():
+        counts[str(status)] = int(count or 0)
+    return counts