Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

5.5 KB
Raw Blame
from collections.abc import Collection
from dataclasses import dataclass
from datetime import UTC, datetime

from sqlalchemy import exists
from sqlalchemy.orm import Session

from ...database.models import QueuedResearch, QueueStatus, TaskMetadata


@dataclass(frozen=True, slots=True)
class QueuedResearchCleanupResult:
    """Cleaned and protected IDs can overlap for legacy shared queue IDs."""

    cleaned_ids: frozenset[str]
    protected_ids: frozenset[str]


def reconcile_research_queue_status(
    db_session: Session, *, force: bool = False
) -> bool:
    """Recompute research capacity counters without committing the transaction."""
    queued_tasks = (
        db_session.query(TaskMetadata)
        .filter_by(task_type="research", status="queued")
        .count()
    )
    active_tasks = (
        db_session.query(TaskMetadata)
        .filter_by(task_type="research", status="processing")
        .count()
    )
    queue_status = db_session.query(QueueStatus).first()
    if queue_status is None:
        db_session.add(
            QueueStatus(
                active_tasks=active_tasks,
                queued_tasks=queued_tasks,
                last_checked=datetime.now(UTC),
            )
        )
        return True

    changed = (
        queue_status.active_tasks != active_tasks
        or queue_status.queued_tasks != queued_tasks
    )
    if changed or force:
        queue_status.active_tasks = active_tasks
        queue_status.queued_tasks = queued_tasks
        queue_status.last_checked = datetime.now(UTC)
    return changed or force


def cleanup_queued_research_state(
    db_session: Session,
    research_ids: Collection[str],
    include_claimed: bool = False,
    acting_user: str | None = None,
) -> QueuedResearchCleanupResult:
    """Remove queued research state while leaving transaction control to the caller.

    With ``acting_user``, a queue row another user owns is left in place, and so
    is the task metadata of its research ID, which that row still needs. Such
    IDs are reported as protected. ``TaskMetadata`` has no owner column, so
    metadata that no queue row points at is removed either way.
    """
    research_id_set = set(research_ids)
    if not research_id_set:
        return QueuedResearchCleanupResult(frozenset(), frozenset())

    claimed_ids: set[str] = set()
    if not include_claimed:
        claimed_ids = {
            research_id
            for (research_id,) in (
                db_session.query(QueuedResearch.research_id)
                .filter(
                    QueuedResearch.research_id.in_(research_id_set),
                    QueuedResearch.is_processing.is_(True),
                )
                .all()
            )
        }
    cleanup_ids = research_id_set - claimed_ids
    if not cleanup_ids:
        return QueuedResearchCleanupResult(frozenset(), frozenset(claimed_ids))

    queued_rows = (
        db_session.query(QueuedResearch)
        .filter(QueuedResearch.research_id.in_(cleanup_ids))
        .all()
    )
    foreign_ids: set[str] = set()
    if acting_user is not None:
        foreign_ids = {
            queued_row.research_id
            for queued_row in queued_rows
            if queued_row.username != acting_user
        }
        queued_rows = [
            queued_row
            for queued_row in queued_rows
            if queued_row.username == acting_user
        ]
    usernames = {queued_row.username for queued_row in queued_rows}
    for queued_row in queued_rows:
        db_session.delete(queued_row)

    metadata_ids = cleanup_ids - foreign_ids
    if metadata_ids:
        metadata_query = db_session.query(TaskMetadata).filter(
            TaskMetadata.task_id.in_(metadata_ids),
            TaskMetadata.task_type == "research",
        )
        if acting_user is not None:
            # Ownership must still hold when DELETE executes, not just when
            # queued_rows was loaded. A foreign row may have committed since.
            metadata_query = metadata_query.filter(
                ~exists().where(
                    QueuedResearch.research_id == TaskMetadata.task_id,
                    QueuedResearch.username != acting_user,
                )
            )
        metadata_query.delete(synchronize_session=False)

    if acting_user is not None:
        current_foreign_ids = {
            research_id
            for (research_id,) in db_session.query(QueuedResearch.research_id)
            .filter(
                QueuedResearch.research_id.in_(cleanup_ids),
                QueuedResearch.username != acting_user,
            )
            .all()
        }
        late_foreign_ids = current_foreign_ids - foreign_ids
        # Preserve existing result semantics for preloaded shared IDs. Only
        # reconcile the newly protected IDs: own rows were still removed,
        # whereas foreign-only IDs had no state cleaned.
        metadata_ids -= late_foreign_ids - {
            row.research_id for row in queued_rows
        }
        foreign_ids |= current_foreign_ids

    for username in usernames:
        surviving_rows = (
            db_session.query(QueuedResearch)
            .filter_by(username=username)
            .order_by(QueuedResearch.position, QueuedResearch.id)
            .all()
        )
        for position, queued_row in enumerate(surviving_rows, start=1):
            queued_row.position = position

    reconcile_research_queue_status(db_session, force=True)
    return QueuedResearchCleanupResult(
        frozenset(metadata_ids | {row.research_id for row in queued_rows}),
        frozenset(claimed_ids | foreign_ids),
    )