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.

4.2 KB
Raw Blame
from __future__ import annotations

from dataclasses import dataclass
from datetime import UTC, datetime
from queue import Empty, SimpleQueue
from types import TracebackType
from typing import Protocol, TypeAlias


from sqlalchemy import func, select
from sqlalchemy.orm import Session

from local_deep_research.constants import ResearchStatus
from local_deep_research.database.models import (
    QueueStatus,
    QueuedResearch,
    ResearchHistory,
    TaskMetadata,
    UserActiveResearch,
)
from local_deep_research.database.queue_service import UserQueueService


class ConnectedUserFixture(Protocol):
    # Was ``FlaskClient[Flask]``; under FastAPI the branch's ``client``
    # fixture hands back a Flask-compat-shimmed Starlette TestClient.
    client: object
    username: str
    password: str


@dataclass(frozen=True, slots=True)
class QueueResearchSeed:
    research_id: str
    position: int
    status: ResearchStatus = ResearchStatus.QUEUED
    is_processing: bool = False


QueueState: TypeAlias = tuple[str, int, int, str | None, int, int, int]


@dataclass(frozen=True, slots=True)
class WorkerFailure:
    exception: BaseException
    traceback: TracebackType | None


def raise_worker_failures(worker_failures: SimpleQueue[WorkerFailure]) -> None:
    failures: list[WorkerFailure] = []
    while True:
        try:
            failures.append(worker_failures.get_nowait())
        except Empty:
            break
    if not failures:
        return
    if len(failures) > 1:
        # BaseExceptionGroup, not ExceptionGroup: WorkerFailure.exception is
        # a BaseException, which ExceptionGroup refuses to nest.
        raise BaseExceptionGroup(
            "multiple worker failures",
            [f.exception.with_traceback(f.traceback) for f in failures],
        )
    raise failures[0].exception.with_traceback(failures[0].traceback)


def _register_connected_user(case: ConnectedUserFixture) -> None:
    # Registration now sits behind CSRFMiddleware and httpx follows
    # redirects by default; both are handled in the shared helper.
    from tests.connected.conftest import register_connected_user

    register_connected_user(case)


def _seed_queued_research(
    db_session: Session,
    username: str,
    seed: QueueResearchSeed,
) -> None:
    query = f"connected queue research {seed.research_id}"
    db_session.add(
        ResearchHistory(
            id=seed.research_id,
            query=query,
            mode="quick",
            status=seed.status,
            created_at=datetime.now(UTC).isoformat(),
        )
    )
    db_session.add(
        QueuedResearch(
            username=username,
            research_id=seed.research_id,
            query=query,
            mode="quick",
            settings_snapshot={
                "submission": {"strategy": "source-based"},
                "settings_snapshot": {},
            },
            position=seed.position,
            is_processing=seed.is_processing,
        )
    )
    UserQueueService(db_session).add_task_metadata(
        task_id=seed.research_id, task_type="research", priority=seed.position
    )


def _queue_state(db_session: Session, research_id: str) -> QueueState:
    active_tasks, queued_tasks = db_session.execute(
        select(QueueStatus.active_tasks, QueueStatus.queued_tasks)
    ).one()
    return (
        db_session.execute(
            select(ResearchHistory.status).where(
                ResearchHistory.id == research_id
            )
        ).scalar_one(),
        db_session.execute(
            select(func.count(QueuedResearch.id)).where(
                QueuedResearch.research_id == research_id
            )
        ).scalar_one(),
        db_session.execute(
            select(func.count(QueuedResearch.id)).where(
                QueuedResearch.research_id == research_id,
                QueuedResearch.is_processing.is_(True),
            )
        ).scalar_one(),
        db_session.execute(
            select(TaskMetadata.status).where(
                TaskMetadata.task_id == research_id
            )
        ).scalar_one_or_none(),
        db_session.execute(
            select(func.count(UserActiveResearch.research_id)).where(
                UserActiveResearch.research_id == research_id
            )
        ).scalar_one(),
        active_tasks,
        queued_tasks,
    )