~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.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
from __future__ import annotations
import threading
from queue import SimpleQueue
from uuid import uuid4
import pytest
from sqlalchemy import event
from sqlalchemy.pool import QueuePool
from local_deep_research.constants import ResearchStatus
from local_deep_research.database.encrypted_db import db_manager
from local_deep_research.database.queue_service import UserQueueService
from local_deep_research.database.session_context import get_user_db_session
from local_deep_research.web.queue.processor_v2 import QueueProcessorV2
from tests.connected.queue_test_support import (
ConnectedUserFixture,
QueueResearchSeed,
QueueState,
WorkerFailure,
_queue_state,
_register_connected_user,
_seed_queued_research,
raise_worker_failures,
)
def test_conditional_atomic_claim_allows_one_same_id_dispatch(
connected_user: ConnectedUserFixture,
monkeypatch: pytest.MonkeyPatch,
) -> None:
case = connected_user
monkeypatch.setattr(db_manager, "_use_static_pool", False)
monkeypatch.setattr(db_manager, "_pool_class", QueuePool)
_register_connected_user(case)
research_id = str(uuid4())
processors = (QueueProcessorV2(), QueueProcessorV2())
claim_update_barrier = threading.Barrier(2)
processor_start_barrier = threading.Barrier(2)
worker_spawn_entered = threading.Event()
allow_worker_spawn_to_return = threading.Event()
conditional_claim_seen = threading.Event()
unconditional_claim_seen = threading.Event()
spawn_states: list[QueueState] = []
dispatches: list[str] = []
session_ids: list[int] = []
dbapi_connection_ids: list[int] = []
worker_failures: SimpleQueue[WorkerFailure] = SimpleQueue()
with get_user_db_session(case.username, case.password) as db_session:
_seed_queued_research(
db_session,
case.username,
QueueResearchSeed(research_id=research_id, position=1),
)
engine = db_manager.open_user_database(case.username, case.password)
assert engine is not None
def record_dbapi_connection(
dbapi_connection, _connection_record, _connection_proxy
) -> None:
dbapi_connection_ids.append(id(dbapi_connection))
def synchronize_claim_update(
_connection,
_cursor,
statement: str,
_parameters,
_context,
_executemany,
) -> None:
normalized_statement = statement.lower()
if normalized_statement.startswith("update queued_researches"):
conditional_claim_present = (
"is_processing is 0" in normalized_statement
or "is_processing = 0" in normalized_statement
)
if conditional_claim_present:
conditional_claim_seen.set()
else:
unconditional_claim_seen.set()
claim_update_barrier.wait(timeout=5)
def record_claimed_spawn(
claimed_research_id: str, *_args, **_kwargs
) -> threading.Thread:
with get_user_db_session(case.username, case.password) as db_session:
spawn_states.append(_queue_state(db_session, claimed_research_id))
dispatches.append(claimed_research_id)
worker_spawn_entered.set()
assert allow_worker_spawn_to_return.wait(timeout=5)
return threading.current_thread()
event.listen(engine, "checkout", record_dbapi_connection)
event.listen(engine, "before_cursor_execute", synchronize_claim_update)
monkeypatch.setattr(
"local_deep_research.web.queue.processor_v2.start_research_process",
record_claimed_spawn,
)
def claim_research(processor: QueueProcessorV2) -> None:
try:
processor_start_barrier.wait(timeout=5)
with get_user_db_session(
case.username, case.password
) as db_session:
session_ids.append(id(db_session))
processor._start_queued_researches(
db_session,
UserQueueService(db_session),
case.username,
case.password,
1,
)
except BaseException as exception:
worker_failures.put(
WorkerFailure(exception, exception.__traceback__)
)
claim_threads = tuple(
threading.Thread(target=claim_research, args=(processor,))
for processor in processors
)
for claim_thread in claim_threads:
claim_thread.start()
worker_spawned = False
try:
worker_spawned = worker_spawn_entered.wait(timeout=5)
finally:
allow_worker_spawn_to_return.set()
for claim_thread in claim_threads:
claim_thread.join(timeout=5)
event.remove(engine, "before_cursor_execute", synchronize_claim_update)
event.remove(engine, "checkout", record_dbapi_connection)
assert all(not claim_thread.is_alive() for claim_thread in claim_threads)
raise_worker_failures(worker_failures)
assert worker_spawned
expected_claimed_state: QueueState = (
ResearchStatus.IN_PROGRESS,
1,
1,
"processing",
0,
1,
0,
)
assert len(set(session_ids)) == 2
assert len(set(dbapi_connection_ids)) == 2
assert dispatches == [research_id]
assert spawn_states == [expected_claimed_state]
assert conditional_claim_seen.is_set()
assert not unconditional_claim_seen.is_set()
with get_user_db_session(case.username, case.password) as db_session:
assert _queue_state(db_session, research_id) == (
ResearchStatus.IN_PROGRESS,
0,
0,
"processing",
1,
1,
0,
)