Chris CoutinhoandClaude Opus 4.8
9676bb3106
Split external (procrastinate) document processing into per-tier queues so a
document is attempted at most once per tier and requeued to the next tier's
queue on a low-quality parse, using procrastinate's native retry.
- escalation.py: TIER_LADDER (fast->structured->ocr) + EscalateError signal
- registry: process_tier (one tier) + evaluate_escalation post-parse gate
(reuses classify_from_text) + next_available_tier; shared _classify_result
and _oversize_result with the inline pipeline
- processor: process_document(tier=...) runs one tier and raises EscalateError
before embed (junk text never indexed); inline memory path unchanged
- queue/procrastinate: ingest-fast|structured|ocr queues; TieredEscalationStrategy
(queue-hop on EscalateError, bounded same-tier transient retry); queue-aware
task; producer defers to ingest-fast; per-queue counts + all-queue reclaim
- cli: worker --tier {fast,structured,ocr}
- billing: pages_ocr usage event + pipeline_tier metadata (paid OCR billed apart)
- observability: astrolabe_ingest_queue_depth{queue,status} gauge + per-queue
counts in nc_get_vector_sync_status / management status endpoint
- config: INGEST_ESCALATION_ENABLED (default true), INGEST_TRANSIENT_MAX_ATTEMPTS
INGEST_ESCALATION_ENABLED=false and INGEST_QUEUE=memory preserve prior behaviour.
Deck #323.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
71 lines
2.6 KiB
Python
71 lines
2.6 KiB
Python
"""Unit tests for the per-tier PDF parse + escalation gate (Deck #323).
|
|
|
|
``processor._parse_pdf_tier`` runs one tier and either returns the result to
|
|
index or raises ``EscalateError`` (a queue-hop). These exercise the decision
|
|
without standing up the full ingest pipeline.
|
|
"""
|
|
|
|
from unittest.mock import AsyncMock, MagicMock
|
|
|
|
import pytest
|
|
|
|
from nextcloud_mcp_server.document_processors.base import ProcessingResult
|
|
from nextcloud_mcp_server.document_processors.escalation import EscalateError
|
|
from nextcloud_mcp_server.vector import processor
|
|
|
|
pytestmark = pytest.mark.unit
|
|
|
|
|
|
def _registry(result: ProcessingResult, decision):
|
|
reg = MagicMock()
|
|
reg.process_tier = AsyncMock(return_value=result)
|
|
reg.evaluate_escalation = MagicMock(return_value=decision)
|
|
return reg
|
|
|
|
|
|
async def test_good_parse_returns_result(monkeypatch):
|
|
rec = MagicMock()
|
|
monkeypatch.setattr(processor, "record_document_escalation", rec)
|
|
result = ProcessingResult(text="clean", metadata={}, processor="fast")
|
|
reg = _registry(result, decision=None)
|
|
out = await processor._parse_pdf_tier(
|
|
reg, b"%PDF", "application/pdf", "f.pdf", "fast", settings=object()
|
|
)
|
|
assert out is result
|
|
rec.assert_not_called()
|
|
|
|
|
|
async def test_low_quality_parse_raises_escalate(monkeypatch):
|
|
rec = MagicMock()
|
|
monkeypatch.setattr(processor, "record_document_escalation", rec)
|
|
result = ProcessingResult(text="", metadata={}, processor="fast")
|
|
reg = _registry(result, decision=("ocr", "empty_text"))
|
|
with pytest.raises(EscalateError) as ei:
|
|
await processor._parse_pdf_tier(
|
|
reg, b"%PDF", "application/pdf", "f.pdf", "fast", settings=object()
|
|
)
|
|
assert ei.value.from_tier == "fast"
|
|
assert ei.value.to_tier == "ocr"
|
|
assert ei.value.reason == "empty_text"
|
|
# The escalation is recorded at the decision point.
|
|
rec.assert_called_once_with("fast", "ocr", "empty_text")
|
|
|
|
|
|
async def test_hard_failure_returns_result_without_escalating(monkeypatch):
|
|
rec = MagicMock()
|
|
monkeypatch.setattr(processor, "record_document_escalation", rec)
|
|
result = ProcessingResult(
|
|
text="",
|
|
metadata={"parse_failed_reason": "oversize"},
|
|
processor="size_guard",
|
|
success=False,
|
|
)
|
|
reg = _registry(result, decision=("ocr", "empty_text"))
|
|
out = await processor._parse_pdf_tier(
|
|
reg, b"%PDF", "application/pdf", "big.pdf", "fast", settings=object()
|
|
)
|
|
# success=False short-circuits: the gate is never consulted, no escalation.
|
|
assert out is result
|
|
reg.evaluate_escalation.assert_not_called()
|
|
rec.assert_not_called()
|