From e2b273ee2a93e22c6a3d87edd31c63b0550dca96 Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Sun, 26 Jul 2026 13:30:59 +0300 Subject: [PATCH 01/16] Consolidate duplicated client-side tests Parametrize sibling tests that differed only in a literal value, and fold two strict-subset tests into the survivors that already covered their scenario. Every case that ran before still runs; the union of assertions is applied to each case, strengthening list_all, get_pages_data and resolve_doc_items. Replace four hand-rolled log-capture handlers with a shared capture_logs() contextmanager in conftest. 13 fewer test functions, 348 fewer lines. --- ...=> test_chunk_content_fts[populated].yaml} | 0 ..._chunk_content_fts[without_headings].yaml} | 0 ...reate_document_from_source_with_title.yaml | 42 -- ...client_unchanged_file_keeps_timestamp.yaml | 42 -- tests/conftest.py | 27 ++ tests/test_chunk.py | 428 +++++++----------- tests/test_client.py | 42 +- tests/test_document.py | 69 +-- tests/test_processing.py | 19 +- tests/test_rebuild.py | 34 +- tests/test_search.py | 119 +---- 11 files changed, 237 insertions(+), 585 deletions(-) rename tests/cassettes/test_chunk/{test_chunk_content_fts_populated.yaml => test_chunk_content_fts[populated].yaml} (100%) rename tests/cassettes/test_chunk/{test_chunk_content_fts_without_headings.yaml => test_chunk_content_fts[without_headings].yaml} (100%) delete mode 100644 tests/cassettes/test_client/test_client_create_document_from_source_with_title.yaml delete mode 100644 tests/cassettes/test_client/test_client_unchanged_file_keeps_timestamp.yaml diff --git a/tests/cassettes/test_chunk/test_chunk_content_fts_populated.yaml b/tests/cassettes/test_chunk/test_chunk_content_fts[populated].yaml similarity index 100% rename from tests/cassettes/test_chunk/test_chunk_content_fts_populated.yaml rename to tests/cassettes/test_chunk/test_chunk_content_fts[populated].yaml diff --git a/tests/cassettes/test_chunk/test_chunk_content_fts_without_headings.yaml b/tests/cassettes/test_chunk/test_chunk_content_fts[without_headings].yaml similarity index 100% rename from tests/cassettes/test_chunk/test_chunk_content_fts_without_headings.yaml rename to tests/cassettes/test_chunk/test_chunk_content_fts[without_headings].yaml diff --git a/tests/cassettes/test_client/test_client_create_document_from_source_with_title.yaml b/tests/cassettes/test_client/test_client_create_document_from_source_with_title.yaml deleted file mode 100644 index 3ce22209..00000000 --- a/tests/cassettes/test_client/test_client_create_document_from_source_with_title.yaml +++ /dev/null @@ -1,42 +0,0 @@ -interactions: -- request: - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate, zstd - connection: - - keep-alive - content-length: - - '103' - content-type: - - application/json - host: - - localhost:11434 - method: POST - parsed_body: - encoding_format: base64 - input: - - This is test content from a file. - model: qwen3-embedding:4b - uri: http://localhost:11434/v1/embeddings - response: - headers: - content-type: - - application/json - transfer-encoding: - - chunked - parsed_body: - data: - - embedding: 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 - index: 0 - object: embedding - model: qwen3-embedding:4b - object: list - usage: - prompt_tokens: 9 - total_tokens: 9 - status: - code: 200 - message: OK -version: 1 diff --git a/tests/cassettes/test_client/test_client_unchanged_file_keeps_timestamp.yaml b/tests/cassettes/test_client/test_client_unchanged_file_keeps_timestamp.yaml deleted file mode 100644 index cbf424cb..00000000 --- a/tests/cassettes/test_client/test_client_unchanged_file_keeps_timestamp.yaml +++ /dev/null @@ -1,42 +0,0 @@ -interactions: -- request: - headers: - accept: - - application/json - accept-encoding: - - gzip, deflate, zstd - connection: - - keep-alive - content-length: - - '103' - content-type: - - application/json - host: - - localhost:11434 - method: POST - parsed_body: - encoding_format: base64 - input: - - Test content for timestamp check. - model: qwen3-embedding:4b - uri: http://localhost:11434/v1/embeddings - response: - headers: - content-type: - - application/json - transfer-encoding: - - chunked - parsed_body: - data: - - embedding: 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 - index: 0 - object: embedding - model: qwen3-embedding:4b - object: list - usage: - prompt_tokens: 7 - total_tokens: 7 - status: - code: 200 - message: OK -version: 1 diff --git a/tests/conftest.py b/tests/conftest.py index b5924d74..fb5229c1 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -2,6 +2,8 @@ import json import logging import os import tempfile +from collections.abc import Iterator +from contextlib import contextmanager from pathlib import Path from typing import TYPE_CHECKING, Any @@ -32,6 +34,31 @@ setattr(pydantic_ai.models, "ALLOW_MODEL_REQUESTS", False) logging.getLogger("vcr.cassette").setLevel(logging.WARNING) +@contextmanager +def capture_logs( + logger: logging.Logger, level: int +) -> Iterator[list[logging.LogRecord]]: + """Collect records emitted by ``logger`` at or above ``level``. + + Attaches directly to the given logger instead of using ``caplog``: + ``haiku.rag.logging.get_logger()`` sets ``propagate=False`` on the + ``haiku.rag`` logger, so records never reach caplog's root handler once + any test in the session has called it. + """ + records: list[logging.LogRecord] = [] + + class _ListHandler(logging.Handler): + def emit(self, record: logging.LogRecord) -> None: + records.append(record) + + handler = _ListHandler(level=level) + logger.addHandler(handler) + try: + yield records + finally: + logger.removeHandler(handler) + + @pytest.fixture(scope="session") def qa_corpus() -> list[dict[str, str]]: corpus_path = Path(__file__).parent / "data" / "qa_corpus.json" diff --git a/tests/test_chunk.py b/tests/test_chunk.py index c33637ae..f540528b 100644 --- a/tests/test_chunk.py +++ b/tests/test_chunk.py @@ -3,6 +3,7 @@ import pytest from haiku.rag.client import HaikuRAG from haiku.rag.config import Config from haiku.rag.store.models.chunk import Chunk, ChunkMetadata, SearchResult +from tests.conftest import capture_logs @pytest.mark.vcr() @@ -123,136 +124,86 @@ async def test_chunking_pipeline(qa_corpus: list[dict[str, str]], temp_db_path): assert chunk.order == i -def test_chunk_metadata_parsing(): +@pytest.mark.parametrize( + "metadata,refs,headings,labels,page_numbers", + [ + ( + { + "doc_item_refs": ["#/texts/0", "#/texts/1", "#/tables/0"], + "headings": ["Chapter 1", "Section 1.1"], + "labels": ["paragraph", "paragraph", "table"], + "page_numbers": [1, 1, 2], + }, + ["#/texts/0", "#/texts/1", "#/tables/0"], + ["Chapter 1", "Section 1.1"], + ["paragraph", "paragraph", "table"], + [1, 1, 2], + ), + ({}, [], None, [], []), + ], + ids=["populated", "defaults"], +) +def test_chunk_metadata_parsing(metadata, refs, headings, labels, page_numbers): """Test ChunkMetadata parsing from chunk metadata dict.""" - metadata_dict = { - "doc_item_refs": ["#/texts/0", "#/texts/1", "#/tables/0"], - "headings": ["Chapter 1", "Section 1.1"], - "labels": ["paragraph", "paragraph", "table"], - "page_numbers": [1, 1, 2], - } - - chunk = Chunk( - content="Test content", - metadata=metadata_dict, - ) + chunk = Chunk(content="Test content", metadata=metadata) chunk_meta = chunk.get_chunk_metadata() assert isinstance(chunk_meta, ChunkMetadata) - assert chunk_meta.doc_item_refs == ["#/texts/0", "#/texts/1", "#/tables/0"] - assert chunk_meta.headings == ["Chapter 1", "Section 1.1"] - assert chunk_meta.labels == ["paragraph", "paragraph", "table"] - assert chunk_meta.page_numbers == [1, 1, 2] + assert chunk_meta.doc_item_refs == refs + assert chunk_meta.headings == headings + assert chunk_meta.labels == labels + assert chunk_meta.page_numbers == page_numbers -def test_chunk_metadata_defaults(): - """Test ChunkMetadata with empty/default values.""" - chunk = Chunk(content="Test content", metadata={}) - chunk_meta = chunk.get_chunk_metadata() +@pytest.fixture +def two_text_docling_doc(): + """Minimal DoclingDocument with two resolvable text items.""" + from docling_core.types.doc.document import DoclingDocument - assert chunk_meta.doc_item_refs == [] - assert chunk_meta.headings is None - assert chunk_meta.labels == [] - assert chunk_meta.page_numbers == [] + return DoclingDocument.model_validate( + { + "name": "test_doc", + "texts": [ + { + "self_ref": "#/texts/0", + "text": "First text", + "orig": "First text", + "label": "paragraph", + }, + { + "self_ref": "#/texts/1", + "text": "Second text", + "orig": "Second text", + "label": "title", + }, + ], + "tables": [], + "pictures": [], + "groups": [], + "body": {"self_ref": "#/body", "children": []}, + "furniture": {"self_ref": "#/furniture", "children": []}, + } + ) -def test_chunk_metadata_resolve_doc_items(): +@pytest.mark.parametrize( + "refs,expected_texts", + [ + (["#/texts/0", "#/texts/1"], ["First text", "Second text"]), + # Out-of-range and malformed refs are skipped rather than raising. + (["#/texts/0", "#/texts/999", "#/invalid/path"], ["First text"]), + ([], []), + ], + ids=["all_valid", "graceful_degradation", "empty_refs"], +) +def test_chunk_metadata_resolve_doc_items(two_text_docling_doc, refs, expected_texts): """Test resolving doc_item_refs to actual DocItem objects.""" - from docling_core.types.doc.document import DoclingDocument + chunk_meta = ChunkMetadata(doc_item_refs=refs) - # Create a minimal DoclingDocument with some text items - doc_json = { - "name": "test_doc", - "texts": [ - { - "self_ref": "#/texts/0", - "text": "First text", - "orig": "First text", - "label": "paragraph", - }, - { - "self_ref": "#/texts/1", - "text": "Second text", - "orig": "Second text", - "label": "title", - }, - ], - "tables": [], - "pictures": [], - "groups": [], - "body": {"self_ref": "#/body", "children": []}, - "furniture": {"self_ref": "#/furniture", "children": []}, - } - docling_doc = DoclingDocument.model_validate(doc_json) + doc_items = chunk_meta.resolve_doc_items(two_text_docling_doc) - # Create chunk metadata with refs - chunk_meta = ChunkMetadata( - doc_item_refs=["#/texts/0", "#/texts/1"], - labels=["paragraph", "title"], - ) - - # Resolve refs - doc_items = chunk_meta.resolve_doc_items(docling_doc) - - assert len(doc_items) == 2 - assert getattr(doc_items[0], "text") == "First text" - assert getattr(doc_items[1], "text") == "Second text" - - -def test_chunk_metadata_resolve_doc_items_graceful_degradation(): - """Test that invalid refs are skipped gracefully.""" - from docling_core.types.doc.document import DoclingDocument - - doc_json = { - "name": "test_doc", - "texts": [ - { - "self_ref": "#/texts/0", - "text": "Only text", - "orig": "Only text", - "label": "paragraph", - }, - ], - "tables": [], - "pictures": [], - "groups": [], - "body": {"self_ref": "#/body", "children": []}, - "furniture": {"self_ref": "#/furniture", "children": []}, - } - docling_doc = DoclingDocument.model_validate(doc_json) - - # Create chunk metadata with one valid and one invalid ref - chunk_meta = ChunkMetadata( - doc_item_refs=["#/texts/0", "#/texts/999", "#/invalid/path"], - ) - - # Resolve refs - invalid ones should be skipped - doc_items = chunk_meta.resolve_doc_items(docling_doc) - - assert len(doc_items) == 1 - assert getattr(doc_items[0], "text") == "Only text" - - -def test_chunk_metadata_resolve_empty_refs(): - """Test resolving with no refs returns empty list.""" - from docling_core.types.doc.document import DoclingDocument - - doc_json = { - "name": "test_doc", - "texts": [], - "tables": [], - "pictures": [], - "groups": [], - "body": {"self_ref": "#/body", "children": []}, - "furniture": {"self_ref": "#/furniture", "children": []}, - } - docling_doc = DoclingDocument.model_validate(doc_json) - - chunk_meta = ChunkMetadata() - doc_items = chunk_meta.resolve_doc_items(docling_doc) - - assert doc_items == [] + assert [getattr(item, "text") for item in doc_items] == expected_texts def test_search_result_from_chunk_preserves_document_meta(): @@ -286,11 +237,12 @@ def test_search_result_format_for_agent_omits_document_meta(): assert "https://example.org/report/view" not in formatted -def test_search_result_format_for_agent_with_rank(): - """Test format_for_agent with rank and total parameters.""" - result = SearchResult( +@pytest.fixture +def rich_search_result(): + """SearchResult with every optional field populated.""" + return SearchResult( content="This is the chunk content about elections.", - score=0.02, # Low RRF score that would confuse agents + score=0.85, chunk_id="chunk-123", document_id="doc-456", document_uri="file:///docs/report.pdf", @@ -300,16 +252,30 @@ def test_search_result_format_for_agent_with_rank(): page_numbers=[1, 2], ) - formatted = result.format_for_agent(rank=1, total=5) +@pytest.mark.parametrize( + "kwargs,present,absent", + [ + # A rank is supplied, so the raw RRF score is withheld from the agent. + ({"rank": 1, "total": 5}, "[rank 1 of 5]", "score:"), + ({}, "(score: 0.85)", "[rank"), + ], + ids=["with_rank", "score_fallback"], +) +def test_search_result_format_for_agent_rank_vs_score( + rich_search_result, kwargs, present, absent +): + """format_for_agent shows a rank when given one, else falls back to score.""" + formatted = rich_search_result.format_for_agent(**kwargs) + + assert present in formatted + assert absent not in formatted assert "[chunk-123]" in formatted - assert "[rank 1 of 5]" in formatted - assert "score:" not in formatted # Score should NOT appear when rank is provided assert ( 'Source: "Annual Report 2024" > Chapter 1 > Section 1.1 > Elections' in formatted ) - assert "Type: table" in formatted + assert "Type: table" in formatted # table has higher priority than paragraph assert "Content:\nThis is the chunk content about elections." in formatted @@ -357,134 +323,104 @@ def test_search_result_format_for_agent_no_captions_no_line(): assert "Figure caption" not in formatted -def test_search_result_format_for_agent_rank_only(): - """Test format_for_agent with rank but no total.""" - result = SearchResult( - content="Some content.", - score=0.03, - chunk_id="chunk-abc", - ) - - formatted = result.format_for_agent(rank=2) - - assert "[chunk-abc]" in formatted - assert "[rank 2]" in formatted - assert "score:" not in formatted - - -def test_search_result_format_for_agent_fallback(): - """Test format_for_agent falls back to score when no rank provided.""" - result = SearchResult( - content="This is the chunk content about elections.", - score=0.85, - chunk_id="chunk-123", - document_id="doc-456", - document_uri="file:///docs/report.pdf", - document_title="Annual Report 2024", - headings=["Chapter 1", "Section 1.1", "Elections"], - labels=["paragraph", "table"], - page_numbers=[1, 2], - ) - - formatted = result.format_for_agent() - - assert "[chunk-123]" in formatted - assert "(score: 0.85)" in formatted - assert ( - 'Source: "Annual Report 2024" > Chapter 1 > Section 1.1 > Elections' - in formatted - ) - assert "Type: table" in formatted # table has higher priority than paragraph - assert "Content:\nThis is the chunk content about elections." in formatted - - -def test_search_result_format_for_agent_minimal(): - """Test format_for_agent with minimal metadata.""" +@pytest.mark.parametrize( + "kwargs,present,absent", + [ + ({"rank": 2}, "[rank 2]", ["score:"]), + # No structural metadata at all, so no Source:/Type: lines are emitted. + ({}, "(score: 0.72)", ["[rank", "Source:", "Type:"]), + ], + ids=["rank_only", "minimal"], +) +def test_search_result_format_for_agent_minimal(kwargs, present, absent): + """A result carrying only content/score/chunk_id formats without metadata lines.""" result = SearchResult( content="Some content here.", score=0.72, chunk_id="chunk-abc", ) - formatted = result.format_for_agent() + formatted = result.format_for_agent(**kwargs) assert "[chunk-abc]" in formatted - assert "(score: 0.72)" in formatted - assert "Source:" not in formatted # No title or headings - assert "Type:" not in formatted # No labels + assert present in formatted + for token in absent: + assert token not in formatted assert "Content:\nSome content here." in formatted -def test_search_result_format_for_agent_title_only(): - """Test format_for_agent with only document title.""" +@pytest.mark.parametrize( + "fields,expected_source", + [ + ({"document_title": "My Document"}, 'Source: "My Document"'), + ( + {"headings": ["Introduction", "Background"]}, + "Source: Introduction > Background", + ), + ], + ids=["title_only", "headings_only"], +) +def test_search_result_format_for_agent_source_line(fields, expected_source): + """The Source: line is built from the title, the headings, or both.""" result = SearchResult( content="Content text.", score=0.60, chunk_id="chunk-xyz", - document_title="My Document", + **fields, ) - formatted = result.format_for_agent() - - assert 'Source: "My Document"' in formatted + assert expected_source in result.format_for_agent() -def test_search_result_format_for_agent_headings_only(): - """Test format_for_agent with only headings (no title).""" - result = SearchResult( - content="Content text.", - score=0.60, - chunk_id="chunk-xyz", - headings=["Introduction", "Background"], - ) - - formatted = result.format_for_agent() - - assert "Source: Introduction > Background" in formatted - - -def test_search_result_get_primary_label(): +@pytest.mark.parametrize( + "labels,expected", + [ + (["paragraph", "table", "text"], "table"), + (["paragraph", "code"], "code"), + (["list_item", "code"], "code"), + (["text", "list_item"], "list_item"), + # No structural label: falls through to the first label. + (["paragraph", "text"], "paragraph"), + ([], None), + ], +) +def test_search_result_get_primary_label(labels, expected): """Test _get_primary_label prioritization.""" - # Table takes priority over text labels - result = SearchResult(content="x", score=0.5, labels=["paragraph", "table", "text"]) - assert result._get_primary_label() == "table" - - # Code takes priority over list_item - result = SearchResult(content="x", score=0.5, labels=["list_item", "code"]) - assert result._get_primary_label() == "code" - - # Text labels fall through to first - result = SearchResult(content="x", score=0.5, labels=["paragraph", "text"]) - assert result._get_primary_label() == "paragraph" - - # Empty labels - result = SearchResult(content="x", score=0.5, labels=[]) - assert result._get_primary_label() is None + result = SearchResult(content="x", score=0.5, labels=labels) + assert result._get_primary_label() == expected @pytest.mark.vcr() -async def test_chunk_content_fts_populated(temp_db_path): - """Test that content_fts column is populated with contextualized content.""" +@pytest.mark.parametrize( + "metadata,content,expected_content_fts", + [ + ( + {"headings": ["Chapter 1", "Section 1.1"]}, + "This is the raw chunk content.", + "Chapter 1\nSection 1.1\nThis is the raw chunk content.", + ), + ({}, "Plain content without headings.", "Plain content without headings."), + ], + ids=["populated", "without_headings"], +) +async def test_chunk_content_fts(temp_db_path, metadata, content, expected_content_fts): + """content_fts holds the contextualized content while content stays raw.""" from haiku.rag.embeddings import get_embedder async with HaikuRAG(db_path=temp_db_path, config=Config, create=True) as client: - # Create a chunk with headings chunk = Chunk( document_id="test-doc", - content="This is the raw chunk content.", - metadata={"headings": ["Chapter 1", "Section 1.1"]}, + content=content, + metadata=metadata, order=0, ) - # Generate embedding embedder = get_embedder(Config) embedding = (await embedder.embed_documents([chunk.content]))[0] chunk.embedding = embedding - # Store the chunk await client.chunk_repository.create(chunk) - # Read the raw record from the database records = ( await client.store.chunks_table.query() .where(f"id = '{chunk.id}'") @@ -495,52 +431,8 @@ async def test_chunk_content_fts_populated(temp_db_path): assert len(records) == 1 record = records[0] - # Verify content is raw (no headings) - assert record["content"] == "This is the raw chunk content." - - # Verify content_fts is contextualized (headings + content) - assert ( - record["content_fts"] - == "Chapter 1\nSection 1.1\nThis is the raw chunk content." - ) - - -@pytest.mark.vcr() -async def test_chunk_content_fts_without_headings(temp_db_path): - """Test that content_fts equals content when no headings present.""" - from haiku.rag.embeddings import get_embedder - - async with HaikuRAG(db_path=temp_db_path, config=Config, create=True) as client: - # Create a chunk without headings - chunk = Chunk( - document_id="test-doc", - content="Plain content without headings.", - metadata={}, - order=0, - ) - - # Generate embedding - embedder = get_embedder(Config) - embedding = (await embedder.embed_documents([chunk.content]))[0] - chunk.embedding = embedding - - # Store the chunk - await client.chunk_repository.create(chunk) - - # Read the raw record from the database - records = ( - await client.store.chunks_table.query() - .where(f"id = '{chunk.id}'") - .limit(1) - .to_arrow() - ).to_pylist() - - assert len(records) == 1 - record = records[0] - - # Both should be the same when no headings - assert record["content"] == "Plain content without headings." - assert record["content_fts"] == "Plain content without headings." + assert record["content"] == content + assert record["content_fts"] == expected_content_fts async def test_ensure_fts_index_warns_on_failure(temp_db_path): @@ -557,18 +449,8 @@ async def test_ensure_fts_index_warns_on_failure(temp_db_path): repo.store.chunks_table.create_index = _boom - records: list[logging.LogRecord] = [] - - class _Capture(logging.Handler): - def emit(self, record: logging.LogRecord) -> None: - records.append(record) - - handler = _Capture(level=logging.WARNING) - chunk_module.logger.addHandler(handler) - try: + with capture_logs(chunk_module.logger, logging.WARNING) as records: await repo._ensure_fts_index() - finally: - chunk_module.logger.removeHandler(handler) assert [r for r in records if r.levelno == logging.WARNING] assert any("index build failed" in r.getMessage() for r in records) diff --git a/tests/test_client.py b/tests/test_client.py index c0636e16..19b6fa6c 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -298,23 +298,6 @@ async def test_client_create_document_from_source(temp_db_path): assert "md5" in doc2.metadata -@pytest.mark.vcr() -async def test_client_create_document_from_source_with_title(temp_db_path): - """Test creating a document from a file source with a title.""" - async with HaikuRAG(temp_db_path, create=True) as client: - with tempfile.TemporaryDirectory() as temp_dir: - test_content = "This is test content from a file." - temp_path = Path(temp_dir) / "test_title.txt" - temp_path.write_text(test_content) - - doc = await client.create_document_from_source( - source=temp_path, title="My Doc" - ) - assert isinstance(doc, Document) - assert doc.id is not None - assert doc.title == "My Doc" - - @pytest.mark.vcr() async def test_client_update_title_noop_behavior(temp_db_path): """When content is unchanged, updating title should update document without re-chunking.""" @@ -326,6 +309,7 @@ async def test_client_update_title_noop_behavior(temp_db_path): doc1 = await client.create_document_from_source(temp_path, title="Title A") assert isinstance(doc1, Document) assert doc1.id is not None + assert doc1.title == "Title A" # Re-add with same content but new title doc2 = await client.create_document_from_source(temp_path, title="Title B") @@ -646,12 +630,14 @@ async def test_client_create_update_no_op_behavior(temp_db_path): assert doc1.id is not None assert doc1.content == test_content original_id = doc1.id + original_updated_at = doc1.updated_at # Second call with same content - should return existing document (no-op) doc2 = await client.create_document_from_source(temp_path) assert isinstance(doc2, Document) assert doc2.id == original_id # Same document assert doc2.content == test_content + assert doc2.updated_at == original_updated_at # No-op leaves it untouched # Modify file content updated_content = "Updated content for testing." @@ -669,28 +655,6 @@ async def test_client_create_update_no_op_behavior(temp_db_path): assert retrieved_doc.content == updated_content -@pytest.mark.vcr() -async def test_client_unchanged_file_keeps_timestamp(temp_db_path): - """Test that unchanged files don't update the updated_at timestamp.""" - async with HaikuRAG(temp_db_path, create=True) as client: - # Create a temporary file - test_content = "Test content for timestamp check." - with tempfile.TemporaryDirectory() as temp_dir: - temp_path = Path(temp_dir) / "test.txt" - temp_path.write_text(test_content) - - # First call - create document - doc1 = await client.create_document_from_source(temp_path) - assert isinstance(doc1, Document) - original_updated_at = doc1.updated_at - - # Second call with same content - should not update timestamp - doc2 = await client.create_document_from_source(temp_path) - assert isinstance(doc2, Document) - assert doc2.id == doc1.id - assert doc2.updated_at == original_updated_at # Timestamp should not change - - @pytest.mark.vcr() async def test_client_url_create_update_no_op_behavior(temp_db_path): """Test create/update/no-op behavior for URLs based on MD5 changes.""" diff --git a/tests/test_document.py b/tests/test_document.py index f850915c..a1c2ccb0 100644 --- a/tests/test_document.py +++ b/tests/test_document.py @@ -8,49 +8,33 @@ from haiku.rag.store.repositories.document_item import DocumentItemRepository @pytest.mark.asyncio -async def test_document_list_excludes_content_by_default( - qa_corpus: list[dict[str, str]], temp_db_path +@pytest.mark.parametrize("include_content", [False, True]) +async def test_document_list_all( + qa_corpus: list[dict[str, str]], temp_db_path, include_content ): - """list_all excludes content and docling_document by default.""" + """list_all excludes content and docling_document unless include_content=True.""" async with Store(temp_db_path, create=True) as store: doc_repo = DocumentRepository(store) + content = qa_corpus[0]["document_extracted"] doc = Document( - content=qa_corpus[0]["document_extracted"], + content=content, uri="https://example.com/doc.txt", title="Test Document", metadata={"key": "value"}, ) created = await doc_repo.create(doc) - docs = await doc_repo.list_all() + docs = await doc_repo.list_all(include_content=include_content) assert len(docs) == 1 assert docs[0].id == created.id assert docs[0].title == "Test Document" assert docs[0].uri == "https://example.com/doc.txt" assert docs[0].metadata == {"key": "value"} - assert docs[0].content == "" + assert docs[0].content == (content if include_content else "") assert docs[0].docling_document is None -@pytest.mark.asyncio -async def test_document_list_includes_content_when_requested( - qa_corpus: list[dict[str, str]], temp_db_path -): - """list_all returns content when include_content=True.""" - async with Store(temp_db_path, create=True) as store: - doc_repo = DocumentRepository(store) - - content = qa_corpus[0]["document_extracted"] - doc = Document(content=content, uri="https://example.com/doc.txt") - created = await doc_repo.create(doc) - - docs = await doc_repo.list_all(include_content=True) - assert len(docs) == 1 - assert docs[0].id == created.id - assert docs[0].content == content - - @pytest.mark.asyncio async def test_document_list_with_filter(qa_corpus: list[dict[str, str]], temp_db_path): """Test listing documents with filter clause.""" @@ -391,16 +375,26 @@ async def test_get_docling_data_loads_only_docling_columns( @pytest.mark.asyncio +@pytest.mark.parametrize( + "with_pages", + # Markdown documents have no page images, so their pages blob stays None. + [True, False], + ids=["with_pages", "markdown"], +) async def test_get_pages_data_loads_only_pages_column( - qa_corpus: list[dict[str, str]], temp_db_path + qa_corpus: list[dict[str, str]], temp_db_path, with_pages ): """get_pages_data returns only page image data for a document.""" import json from haiku.rag.store.compression import compress_json - pages_blob = compress_json( - json.dumps({"1": {"size": {"width": 612, "height": 792}, "page_no": 1}}) + pages_blob = ( + compress_json( + json.dumps({"1": {"size": {"width": 612, "height": 792}, "page_no": 1}}) + ) + if with_pages + else None ) async with Store(temp_db_path, create=True) as store: @@ -424,27 +418,6 @@ async def test_get_pages_data_loads_only_pages_column( assert await doc_repo.get_pages_data("nonexistent-id") is None -@pytest.mark.asyncio -async def test_get_pages_data_none_for_markdown_document( - qa_corpus: list[dict[str, str]], temp_db_path -): - """Markdown documents have no page images — get_pages_data returns None pages.""" - async with Store(temp_db_path, create=True) as store: - doc_repo = DocumentRepository(store) - - doc = Document( - content=qa_corpus[0]["document_extracted"], - uri="https://example.com/doc.md", - ) - created = await doc_repo.create(doc) - assert created.id is not None - - result = await doc_repo.get_pages_data(created.id) - assert result is not None - assert result.id == created.id - assert result.docling_pages is None - - @pytest.mark.asyncio async def test_document_get_by_uri_with_special_characters( qa_corpus: list[dict[str, str]], temp_db_path diff --git a/tests/test_processing.py b/tests/test_processing.py index 8e7133d2..65c1ca86 100644 --- a/tests/test_processing.py +++ b/tests/test_processing.py @@ -7,6 +7,7 @@ import pytest from haiku.rag.client.processing import _warn_if_descriptions_missing, convert from haiku.rag.config import AppConfig +from tests.conftest import capture_logs def _doc_with_pictures(*, with_descriptions: bool): @@ -44,24 +45,12 @@ def _doc_without_pictures(): @pytest.fixture -def caplog_warnings(caplog): +def caplog_warnings(): """Capture WARNING-level records from the processing logger.""" - caplog.set_level(logging.WARNING, logger="haiku.rag.client.processing") - # The haiku.rag parent logger sets propagate=False after get_logger() runs, - # which can break caplog under xdist when other tests have already - # configured logging. Attach directly to the module logger. from haiku.rag.client.processing import logger as proc_logger - records: list[logging.LogRecord] = [] - - class _Capture(logging.Handler): - def emit(self, record: logging.LogRecord) -> None: - records.append(record) - - handler = _Capture(level=logging.WARNING) - proc_logger.addHandler(handler) - yield records - proc_logger.removeHandler(handler) + with capture_logs(proc_logger, logging.WARNING) as records: + yield records def test_no_warning_when_picture_description_disabled(caplog_warnings): diff --git a/tests/test_rebuild.py b/tests/test_rebuild.py index c371bae2..50ebc254 100644 --- a/tests/test_rebuild.py +++ b/tests/test_rebuild.py @@ -7,6 +7,7 @@ import pytest from haiku.rag.client import HaikuRAG, RebuildMode from haiku.rag.config import Config +from tests.conftest import capture_logs class ChunkData(TypedDict): @@ -615,25 +616,11 @@ async def test_rebuild_full_source_failure_is_logged_and_skipped( monkeypatch.setattr(client, "create_document_from_source", failing_create) - # Attach directly to the rebuild module's logger rather than - # relying on caplog — `haiku.rag.logging.get_logger()` (invoked - # by other tests) sets `propagate=False` on the `haiku.rag` - # logger, which breaks caplog under xdist ordering. - records: list[logging.LogRecord] = [] - - class _ListHandler(logging.Handler): - def emit(self, record: logging.LogRecord) -> None: - records.append(record) - - handler = _ListHandler(level=logging.ERROR) - rebuild_module.logger.addHandler(handler) - try: + with capture_logs(rebuild_module.logger, logging.ERROR) as records: processed_ids = [ doc_id async for doc_id in client.rebuild_database(mode=RebuildMode.FULL) ] - finally: - rebuild_module.logger.removeHandler(handler) assert processed_ids == [] assert any( @@ -843,7 +830,7 @@ async def test_patch_picture_descriptions_returns_zero_for_doc_without_pictures( @pytest.mark.asyncio -async def test_patch_picture_descriptions_warns_on_missing_bytes(temp_db_path, caplog): +async def test_patch_picture_descriptions_warns_on_missing_bytes(temp_db_path): """When the docling blob has pictures but document_items.picture_data is empty (e.g. legacy DB ingested before A2b), the helper logs a warning and returns 0 instead of trying to drive the VLM with no input.""" @@ -872,23 +859,10 @@ async def test_patch_picture_descriptions_warns_on_missing_bytes(temp_db_path, c where=f"document_id = '{created.id}' AND label = 'picture'", ) - # Capture warnings directly off the rebuild module logger — the - # haiku.rag parent logger is configured non-propagating elsewhere - # in the suite so caplog can miss records. from haiku.rag.client import rebuild as rebuild_module - records: list[logging.LogRecord] = [] - - class _ListHandler(logging.Handler): - def emit(self, record: logging.LogRecord) -> None: - records.append(record) - - handler = _ListHandler(level=logging.WARNING) - rebuild_module.logger.addHandler(handler) - try: + with capture_logs(rebuild_module.logger, logging.WARNING) as records: n = await _patch_picture_descriptions(rag, created) - finally: - rebuild_module.logger.removeHandler(handler) assert n == 0 assert any("no stored picture bytes" in r.getMessage() for r in records) diff --git a/tests/test_search.py b/tests/test_search.py index e1eccf66..982b44f8 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -275,72 +275,35 @@ async def test_fts_search_targets_content_fts_column(temp_db_path): ) -def test_search_result_primary_label_prioritizes_structural_types(): - """Test _get_primary_label prioritizes structural labels correctly.""" - # Table should be prioritized - result = SearchResult( - content="test", - score=0.5, - chunk_id="c1", - document_id="d1", - labels=["paragraph", "table", "text"], - ) - assert result._get_primary_label() == "table" - - # Code should be prioritized over paragraph - result = SearchResult( - content="test", - score=0.5, - chunk_id="c2", - document_id="d2", - labels=["paragraph", "code"], - ) - assert result._get_primary_label() == "code" - - # list_item should be prioritized - result = SearchResult( - content="test", - score=0.5, - chunk_id="c3", - document_id="d3", - labels=["text", "list_item"], - ) - assert result._get_primary_label() == "list_item" - - # Returns first label when no priority match - result = SearchResult( - content="test", - score=0.5, - chunk_id="c4", - document_id="d4", - labels=["paragraph", "text"], - ) - assert result._get_primary_label() == "paragraph" - - # Returns None for empty labels - result = SearchResult( - content="test", - score=0.5, - chunk_id="c5", - document_id="d5", - labels=[], - ) - assert result._get_primary_label() is None - - # Image queries (bytes / PIL.Image) +def _png_bytes_query() -> bytes: + return b"\x89PNG\r\n\x1a\n" + + +def _pil_image_query(): + from PIL import Image as PILImageModule + + return PILImageModule.new("RGB", (8, 8), "red") + + @pytest.mark.asyncio -async def test_search_with_bytes_query_uses_multimodal_embedder( - temp_db_path, monkeypatch +@pytest.mark.parametrize( + "make_query", + [_png_bytes_query, _pil_image_query], + ids=["bytes", "pil"], +) +async def test_search_with_image_query_uses_multimodal_embedder( + temp_db_path, monkeypatch, make_query ): - """``client.search(bytes)`` embeds via ``embed_image`` and dispatches + """``client.search(image)`` embeds via ``embed_image`` and dispatches to vector-only chunk search (skipping FTS and reranker).""" from haiku.rag.embeddings import EmbedderWrapper from haiku.rag.store.models.chunk import Chunk - image_calls: list[bytes] = [] + query = make_query() + image_calls: list = [] class StubMultimodal(EmbedderWrapper): supports_images = True @@ -383,12 +346,12 @@ async def test_search_with_bytes_query_uses_multimodal_embedder( async with HaikuRAG(temp_db_path, create=True) as rag: rag.chunk_repository.search = fake_chunk_search # type: ignore[method-assign] - results = await rag.search(b"\x89PNG\r\n\x1a\n", limit=3, include_images=False) + results = await rag.search(query, limit=3, include_images=False) assert len(results) == 1 assert results[0].score == 0.91 - # The bytes were sent through the image embedder once. - assert image_calls == [b"\x89PNG\r\n\x1a\n"] + # The image was passed through to the image embedder untouched. + assert image_calls == [query] # The chunk repo received a pre-computed vector and an empty text query. assert received_kwargs["query_vector"] == [0.5, 0.5, 0.5, 0.5] assert received_kwargs["query"] == "" @@ -493,42 +456,6 @@ async def test_search_attaches_picture_bytes_for_multimodal_reranker( assert reranked_picture._picture_data is None -@pytest.mark.asyncio -async def test_search_with_pil_image_works_like_bytes(temp_db_path, monkeypatch): - from PIL import Image as PILImageModule - - from haiku.rag.embeddings import EmbedderWrapper - from haiku.rag.store.models.chunk import Chunk - - seen_types: list[type] = [] - - class StubMultimodal(EmbedderWrapper): - supports_images = True - - def __init__(self): - super().__init__(embedder=None, vector_dim=4) - - async def embed_image(self, image): - seen_types.append(type(image)) - return [0.1] * 4 - - monkeypatch.setattr( - "haiku.rag.store.engine.get_embedder", - lambda *a, **kw: StubMultimodal(), - ) - - async def fake_chunk_search(**kwargs): - return [(Chunk(content="x", metadata={}), 1.0)] - - async with HaikuRAG(temp_db_path, create=True) as rag: - rag.chunk_repository.search = fake_chunk_search # type: ignore[method-assign] - img = PILImageModule.new("RGB", (8, 8), "red") - results = await rag.search(img, include_images=False) - - assert len(results) == 1 - assert seen_types == [PILImageModule.Image] - - @pytest.mark.asyncio async def test_search_with_bytes_query_raises_for_text_only_embedder( temp_db_path, From dddaf0f84cf3c94c5ad158666660111e52535942 Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Sun, 26 Jul 2026 18:45:48 +0300 Subject: [PATCH 02/16] Remove unreachable code and fix two defects it surfaced Delete repository methods with no callers (SettingsRepository CRUD, ChunkRepository.update/delete/get_chunks_in_range), the DataFrame branch of _process_search_results whose only caller always passes a query, and guards that cannot be reached from their call sites: the rebuild mode=None default, the staging drop already performed by _resolve_rebuild_recovery, the empty batch skip, two context fast paths, the doctor prefix guard, the poller _task attribute that is never assigned, and a docling caption fallback for a field name no item class defines. set_haiku_version built a recreated settings row from the process-global Config rather than the store's own, so a store opened with a custom config stamped global settings into the database. check_source_accessible called urlparse outside its try block, so a stored URI with a malformed IPv6 host raised ValueError instead of reporting the source as inaccessible, aborting the whole rebuild sweep. --- CHANGELOG.md | 9 ++ haiku_rag_slim/haiku/rag/client/documents.py | 10 ++- haiku_rag_slim/haiku/rag/client/rebuild.py | 9 +- haiku_rag_slim/haiku/rag/context.py | 4 - haiku_rag_slim/haiku/rag/doctor.py | 2 - .../haiku/rag/ingester/pollers/base.py | 4 - haiku_rag_slim/haiku/rag/store/engine.py | 2 +- .../haiku/rag/store/models/document_item.py | 4 - .../haiku/rag/store/repositories/chunk.py | 82 +------------------ .../haiku/rag/store/repositories/settings.py | 41 ---------- tests/test_client.py | 25 ++++++ tests/test_settings.py | 25 ++++++ 12 files changed, 71 insertions(+), 146 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bba53050..cc59c816 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,15 @@ # Changelog ## [Unreleased] +### Fixed + +- `Store.set_haiku_version` stamps the store's own config into a recreated settings row instead of the process-global `Config`. +- `check_source_accessible` returns `False` for a URI that fails to parse instead of raising `ValueError`. + +### Removed + +- `SettingsRepository.create`, `get_by_id`, `update`, `delete`, `list_all` and `ChunkRepository.update`, `delete`, `get_chunks_in_range`. + ## [0.70.0] - 2026-07-25 ### Added diff --git a/haiku_rag_slim/haiku/rag/client/documents.py b/haiku_rag_slim/haiku/rag/client/documents.py index 41e25599..6dca344e 100644 --- a/haiku_rag_slim/haiku/rag/client/documents.py +++ b/haiku_rag_slim/haiku/rag/client/documents.py @@ -906,13 +906,17 @@ async def update_document( def check_source_accessible(uri: str) -> bool: - """Check if a document's source URI is accessible.""" - parsed_url = urlparse(uri) + """Check if a document's source URI is accessible. + + A stored URI that no longer parses (``urlparse`` rejects malformed IPv6 + hosts) counts as inaccessible rather than aborting the caller's sweep. + """ try: + parsed_url = urlparse(uri) if parsed_url.scheme == "file": return Path(parsed_url.path).exists() elif parsed_url.scheme in ("http", "https", "s3"): return True return False - except Exception: + except ValueError: return False diff --git a/haiku_rag_slim/haiku/rag/client/rebuild.py b/haiku_rag_slim/haiku/rag/client/rebuild.py index fb7f5b5a..0ff37cb5 100644 --- a/haiku_rag_slim/haiku/rag/client/rebuild.py +++ b/haiku_rag_slim/haiku/rag/client/rebuild.py @@ -66,7 +66,7 @@ class _StagingMarkerRecord(LanceModel): async def rebuild_database( - client: "HaikuRAG", mode: "RebuildMode | None" = None + client: "HaikuRAG", mode: "RebuildMode" ) -> AsyncGenerator[str, None]: """Rebuild the database with the specified mode. @@ -79,9 +79,6 @@ async def rebuild_database( """ from haiku.rag.client import RebuildMode - if mode is None: - mode = RebuildMode.FULL - async with client.store._rebuild_lock: if mode == RebuildMode.SET_EMBEDDER: await _set_embedder(client) @@ -287,8 +284,6 @@ async def _populate_staging_table(client: "HaikuRAG") -> None: """ db = client.store.db tables = (await db.list_tables()).tables - if _STAGING_TABLE_NAME in tables: - await db.drop_table(_STAGING_TABLE_NAME) staging = await db.create_table(_STAGING_TABLE_NAME, schema=_StagingChunkRecord) if "chunks" not in tables: @@ -301,8 +296,6 @@ async def _populate_staging_table(client: "HaikuRAG") -> None: ) async for batch in stream: rows = batch.to_pylist() - if not rows: - continue records = [ _StagingChunkRecord( id=r["id"], diff --git a/haiku_rag_slim/haiku/rag/context.py b/haiku_rag_slim/haiku/rag/context.py index 79ccb516..51e8375d 100644 --- a/haiku_rag_slim/haiku/rag/context.py +++ b/haiku_rag_slim/haiku/rag/context.py @@ -101,8 +101,6 @@ def _evidence_anchors(content: str, max_chars: int) -> list[str]: mid = len(content) // 2 start = max(0, mid - target // 2) anchors.append(content[start : start + target]) - if not anchors: - anchors.append(content[:max_chars] if max_chars > 0 else content) return anchors @@ -289,8 +287,6 @@ def _add_input_pages_for_surviving_refs( ) -> None: """Fill missing item-table pages from inputs whose own refs all survived.""" surviving = set(refs) - if not surviving: - return for result in original_results: if not result.page_numbers or not result.doc_item_refs: continue diff --git a/haiku_rag_slim/haiku/rag/doctor.py b/haiku_rag_slim/haiku/rag/doctor.py index f6bd51fd..c885dc68 100644 --- a/haiku_rag_slim/haiku/rag/doctor.py +++ b/haiku_rag_slim/haiku/rag/doctor.py @@ -330,8 +330,6 @@ def _common_path_prefix(labels: list[str]) -> str: Returns "" unless the shared prefix is long enough to be worth factoring out of every line (deep URI trees are otherwise unreadable). """ - if len(labels) < 2: - return "" lo, hi = min(labels), max(labels) end = 0 while end < len(lo) and lo[end] == hi[end]: diff --git a/haiku_rag_slim/haiku/rag/ingester/pollers/base.py b/haiku_rag_slim/haiku/rag/ingester/pollers/base.py index e6700b8f..26e992fb 100644 --- a/haiku_rag_slim/haiku/rag/ingester/pollers/base.py +++ b/haiku_rag_slim/haiku/rag/ingester/pollers/base.py @@ -55,7 +55,6 @@ class BasePoller: self._sync = sync_repo self._breaker = breaker or CircuitBreaker(config.circuit_breaker) self._stop = asyncio.Event() - self._task: asyncio.Task | None = None self._last_polled_at: datetime | None = None self._last_skip_reason: str | None = None self._default_max_attempts = default_max_attempts @@ -84,9 +83,6 @@ class BasePoller: async def stop(self) -> None: self._stop.set() - if self._task is not None: - await asyncio.gather(self._task, return_exceptions=True) - self._task = None async def _stagger_start(self) -> bool: """Sleep a random fraction of the interval so pollers sharing an diff --git a/haiku_rag_slim/haiku/rag/store/engine.py b/haiku_rag_slim/haiku/rag/store/engine.py index 1c5cd926..cc177ad8 100644 --- a/haiku_rag_slim/haiku/rag/store/engine.py +++ b/haiku_rag_slim/haiku/rag/store/engine.py @@ -847,7 +847,7 @@ class Store: ) else: # Create new settings record - settings_data = Config.model_dump(mode="json") + settings_data = self._config.model_dump(mode="json") settings_data["version"] = version await self.settings_table.add( [SettingsRecord(id="settings", settings=json.dumps(settings_data))] diff --git a/haiku_rag_slim/haiku/rag/store/models/document_item.py b/haiku_rag_slim/haiku/rag/store/models/document_item.py index e05506cc..f86ec44b 100644 --- a/haiku_rag_slim/haiku/rag/store/models/document_item.py +++ b/haiku_rag_slim/haiku/rag/store/models/document_item.py @@ -105,10 +105,6 @@ def extract_item_text( except Exception: pass - if caption := getattr(item, "caption", None): - if hasattr(caption, "text"): - return caption.text - return None diff --git a/haiku_rag_slim/haiku/rag/store/repositories/chunk.py b/haiku_rag_slim/haiku/rag/store/repositories/chunk.py index 1960b5c9..09cc3498 100644 --- a/haiku_rag_slim/haiku/rag/store/repositories/chunk.py +++ b/haiku_rag_slim/haiku/rag/store/repositories/chunk.py @@ -4,7 +4,6 @@ from typing import TYPE_CHECKING from uuid import uuid4 if TYPE_CHECKING: - import pandas as pd from lancedb.query import AsyncQueryBase from lancedb.index import FTS @@ -153,40 +152,6 @@ class ChunkRepository: order=chunk_record.order, ) - async def update(self, entity: Chunk) -> Chunk: - """Update an existing chunk. - - Chunk must have embedding set before calling this method. - """ - self.store._assert_writable() - assert entity.id, "Chunk ID is required for update" - assert entity.embedding is not None, "Chunk must have an embedding" - - await self.store.chunks_table.update( - { - "document_id": entity.document_id, - "content": entity.content, - "content_fts": self._contextualize_content(entity), - "metadata": json.dumps( - {k: v for k, v in entity.metadata.items() if k != "order"} - ), - "order": int(entity.order), - "vector": entity.embedding, - }, - where=f"id = '{entity.id}'", - ) - return entity - - async def delete(self, entity_id: str) -> bool: - """Delete a chunk by its ID.""" - self.store._assert_writable() - chunk = await self.get_by_id(entity_id) - if chunk is None: - return False - - await self.store.chunks_table.delete(f"id = '{entity_id}'") - return True - async def list_all( self, limit: int | None = None, offset: int | None = None ) -> list[Chunk]: @@ -417,46 +382,10 @@ class ChunkRepository: ) return len(df) - async def get_chunks_in_range( - self, document_id: str, min_order: int, max_order: int - ) -> list[Chunk]: - """Get chunks for a document within an order range. - - Args: - document_id: The document ID to get chunks for. - min_order: Minimum order value (inclusive). - max_order: Maximum order value (inclusive). - - Returns: - List of chunks within the order range. - """ - where = ( - f"document_id = '{document_id}'" - f" AND `order` >= {min_order}" - f" AND `order` <= {max_order}" - ) - results = await query_to_pydantic( - self.store.chunks_table.query().where(where), self.store.ChunkRecord - ) - return [ - Chunk( - id=rec.id, - document_id=rec.document_id, - content=rec.content, - metadata=json.loads(rec.metadata), - order=rec.order, - ) - for rec in results - ] - async def _process_search_results( - self, query_result: "pd.DataFrame | AsyncQueryBase" + self, query_result: "AsyncQueryBase" ) -> list[tuple[Chunk, float]]: - """Process search results into chunks with document info and scores. - - Args: - query_result: Either a pandas DataFrame or a LanceDB async query result - """ + """Process search results into chunks with document info and scores.""" import pandas as pd def extract_scores(df: pd.DataFrame) -> list[float]: @@ -473,12 +402,7 @@ class ChunkRepository: else: raise ValueError("Unknown search result format, cannot extract scores") - # Convert everything to DataFrame for uniform processing - if isinstance(query_result, pd.DataFrame): - df = query_result - else: - # Convert LanceDB query result to DataFrame - df = await query_result.to_pandas() + df = await query_result.to_pandas() # Extract scores scores = extract_scores(df) diff --git a/haiku_rag_slim/haiku/rag/store/repositories/settings.py b/haiku_rag_slim/haiku/rag/store/repositories/settings.py index 5d7fd2e1..d7b2986c 100644 --- a/haiku_rag_slim/haiku/rag/store/repositories/settings.py +++ b/haiku_rag_slim/haiku/rag/store/repositories/settings.py @@ -18,47 +18,6 @@ class SettingsRepository: def __init__(self, store: Store) -> None: self.store = store - async def create(self, entity: dict) -> dict: - """Create settings in the database.""" - settings_record = SettingsRecord(id="settings", settings=json.dumps(entity)) - await self.store.settings_table.add([settings_record]) - return entity - - async def get_by_id(self, entity_id: str) -> dict | None: - """Get settings by ID.""" - results = await query_to_pydantic( - self.store.settings_table.query().where(f"id = '{entity_id}'").limit(1), - SettingsRecord, - ) - - if not results: - return None - - return json.loads(results[0].settings) if results[0].settings else {} - - async def update(self, entity: dict) -> dict: - """Update existing settings.""" - await self.store.settings_table.update( - {"settings": json.dumps(entity)}, where="id = 'settings'" - ) - return entity - - async def delete(self, entity_id: str) -> bool: - """Delete settings by ID.""" - await self.store.settings_table.delete(f"id = '{entity_id}'") - return True - - async def list_all( - self, limit: int | None = None, offset: int | None = None - ) -> list[dict]: - """List all settings.""" - results = await query_to_pydantic( - self.store.settings_table.query(), SettingsRecord - ) - return [ - json.loads(record.settings) if record.settings else {} for record in results - ] - async def get_current_settings(self) -> dict: """Get the current settings.""" results = await query_to_pydantic( diff --git a/tests/test_client.py b/tests/test_client.py index 19b6fa6c..73012dc5 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -14,6 +14,7 @@ from haiku.rag.client.documents import ( DocumentImport, _prepare_document_from_docling, _write_fetch_body, + check_source_accessible, ) from haiku.rag.config import Config from haiku.rag.store.compression import decompress_json @@ -2254,3 +2255,27 @@ async def test_metadata_only_update_waits_for_write_lock(temp_db_path): assert not task.done() updated = await task assert updated.metadata == {"k": "v"} + + +@pytest.mark.parametrize( + "uri,expected", + [ + ("https://example.com/doc.pdf", True), + ("s3://bucket/key", True), + ("mem://not-a-source", False), + # urlparse rejects a malformed IPv6 host; a stored URI that no longer + # parses must not abort the caller's rebuild sweep. + ("http://[::1", False), + ], + ids=["https", "s3", "unknown_scheme", "unparseable"], +) +def test_check_source_accessible(uri, expected): + assert check_source_accessible(uri) is expected + + +def test_check_source_accessible_file_uri(tmp_path): + existing = tmp_path / "there.txt" + existing.write_text("x") + + assert check_source_accessible(existing.as_uri()) is True + assert check_source_accessible((tmp_path / "gone.txt").as_uri()) is False diff --git a/tests/test_settings.py b/tests/test_settings.py index b4e1f478..b2f11626 100644 --- a/tests/test_settings.py +++ b/tests/test_settings.py @@ -44,6 +44,31 @@ async def test_settings_save_and_retrieve(temp_db_path): Config.processing.chunk_size = original_chunk_size +@pytest.mark.asyncio +async def test_set_haiku_version_recreates_row_from_store_config(temp_db_path): + """Recreating a missing settings row stamps the store's own config, not the + process-global one.""" + from haiku.rag.store.engine import Store + from haiku.rag.store.repositories.settings import SettingsRepository + + config = AppConfig() + config.processing.chunk_size = Config.processing.chunk_size + 512 + + async with Store(temp_db_path, config=config, create=True) as store: + settings_repo = SettingsRepository(store) + + await store.settings_table.delete("id = 'settings'") + assert await settings_repo.get_current_settings() == {} + assert await store.get_haiku_version() == "0.0.0" + + await store.set_haiku_version("1.2.3") + + recreated = await settings_repo.get_current_settings() + assert recreated["version"] == "1.2.3" + assert recreated["processing"]["chunk_size"] == config.processing.chunk_size + assert await store.get_haiku_version() == "1.2.3" + + class TestValidateConfigCompatibility: """Tests for validate_config_compatibility method.""" From 1e8e5e9f6fc3670210c206530481842bd4c147f3 Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Sun, 26 Jul 2026 19:14:26 +0300 Subject: [PATCH 03/16] Cover MCP, ingester and converter error paths Add tests for the MCP tools' degradation contracts, malformed WebDAV multistatus bodies, dry-run poller sweeps including the circuit-open and discover-failure paths, FS source scheme and symlink handling, docling-serve zip parsing, and the remaining embedding and reranker helpers. Parametrize _strip_etag. Drop the misplaced pragma on the analyze handler, which sat on the return and left the except uncovered. Add one on the FS symlink OSError guard, which resolve(strict=False) absorbs for every real link. --- .../haiku/rag/ingester/sources/fs.py | 4 +- haiku_rag_slim/haiku/rag/mcp.py | 2 +- tests/ingester/test_fs_source.py | 38 ++++ tests/ingester/test_http_source.py | 11 ++ tests/ingester/test_pollers.py | 156 ++++++++++++++++ tests/ingester/test_webdav_source.py | 171 ++++++++++++++++-- tests/test_chunker.py | 75 ++++++++ tests/test_converters.py | 158 ++++++++++++++++ tests/test_docling_serve_client.py | 26 +++ tests/test_embedder_config.py | 44 +++++ tests/test_mcp.py | 149 +++++++++++++++ tests/test_pdf_split.py | 11 ++ tests/test_reranker.py | 27 +++ 13 files changed, 850 insertions(+), 22 deletions(-) diff --git a/haiku_rag_slim/haiku/rag/ingester/sources/fs.py b/haiku_rag_slim/haiku/rag/ingester/sources/fs.py index 57b2b23d..2e131401 100644 --- a/haiku_rag_slim/haiku/rag/ingester/sources/fs.py +++ b/haiku_rag_slim/haiku/rag/ingester/sources/fs.py @@ -143,7 +143,9 @@ class FSSource: if path.is_symlink(): try: resolved = path.resolve(strict=False) - except OSError: + except OSError: # pragma: no cover - strict=False absorbs + # symlink cycles and missing targets, so no real link + # reaches this; kept as a guard against platform drift. continue if not resolved.is_relative_to(self.root): continue diff --git a/haiku_rag_slim/haiku/rag/mcp.py b/haiku_rag_slim/haiku/rag/mcp.py index 3871fd07..30c2ed11 100644 --- a/haiku_rag_slim/haiku/rag/mcp.py +++ b/haiku_rag_slim/haiku/rag/mcp.py @@ -244,6 +244,6 @@ def create_mcp_server( result = await rag.analyze(question, filter=filter, images=images) return result.answer except Exception as e: - return f"Error running analysis capability: {e!s}" # pragma: no cover + return f"Error running analysis capability: {e!s}" return mcp diff --git a/tests/ingester/test_fs_source.py b/tests/ingester/test_fs_source.py index 31c7b838..105b698b 100644 --- a/tests/ingester/test_fs_source.py +++ b/tests/ingester/test_fs_source.py @@ -330,3 +330,41 @@ async def test_fs_source_fetch_reads_off_event_loop_thread(fs_root: Path): "FSSource._read_body ran on the event-loop thread; the read+hash must " "be dispatched via asyncio.to_thread" ) + + +@pytest.mark.asyncio +async def test_fetch_rejects_foreign_scheme(tmp_path): + """`supports()` short-circuits on scheme, but fetch/head resolve directly, + so the unsupported-scheme path must be handled there too.""" + src = FSSource(root=tmp_path, supported_extensions=[".md"], source_id="local") + + with pytest.raises(UnsupportedSourceError): + await src.fetch("s3://bucket/key.md") + + assert await src.head("s3://bucket/key.md") is None + + +@pytest.mark.asyncio +async def test_fetch_falls_back_to_octet_stream_for_unknown_extension(tmp_path): + target = tmp_path / "data.unknownext" + target.write_bytes(b"payload") + src = FSSource( + root=tmp_path, supported_extensions=[".unknownext"], source_id="local" + ) + + result = await src.fetch(target.as_uri()) + + assert result.content_type == "application/octet-stream" + assert result.body == b"payload" + + +@pytest.mark.asyncio +async def test_discover_skips_symlink_to_missing_in_root_target(tmp_path): + """A broken symlink inside the root resolves to a path that is not a file.""" + (tmp_path / "real.md").write_text("real") + (tmp_path / "broken.md").symlink_to(tmp_path / "absent.md") + src = FSSource(root=tmp_path, supported_extensions=[".md"], source_id="local") + + events = [e async for e in src.discover()] + + assert {e.uri for e in events} == {(tmp_path / "real.md").as_uri()} diff --git a/tests/ingester/test_http_source.py b/tests/ingester/test_http_source.py index 08915e5e..856ad50c 100644 --- a/tests/ingester/test_http_source.py +++ b/tests/ingester/test_http_source.py @@ -422,3 +422,14 @@ async def test_fetch_skips_head_when_no_max_size(): ) await src.fetch("https://example.com/a.md") assert calls == ["GET"] + + +@pytest.mark.asyncio +async def test_aclose_closes_the_http_client(): + src = HTTPSource( + source_id="urls", + urls=[], + transport=httpx.MockTransport(lambda r: httpx.Response(200)), + ) + await src.aclose() + assert src._http.is_closed diff --git a/tests/ingester/test_pollers.py b/tests/ingester/test_pollers.py index d7970d13..b33bc2d3 100644 --- a/tests/ingester/test_pollers.py +++ b/tests/ingester/test_pollers.py @@ -602,3 +602,159 @@ async def test_fs_poller_enqueues_initial_files(tmp_path, jobs, sync): queued = await jobs.list_jobs(source_id="local") assert {Path(j.uri).name for j in queued} == {"a.md", "b.md"} assert all(j.status is JobStatus.QUEUED for j in queued) + + +# --- _dry_run_once --- + + +@pytest.mark.asyncio +async def test_dry_run_collects_changes_without_writing(fs_config, jobs, sync): + source = _StubSource( + "src", + [ + [ + _event("file:///a.md"), + _event("file:///b.md", kind=SourceEventKind.UNCHANGED), + _event("file:///c.md", kind=SourceEventKind.DELETE), + ] + ], + ) + poller = _periodic(source, fs_config, jobs, sync) + + ok, summary, changes = await poller._dry_run_once() + + assert ok is True + assert summary.upsert_count == 1 + assert summary.unchanged_count == 1 + assert summary.delete_count == 1 + assert {c.op for c in changes} == {JobOp.UPSERT, JobOp.DELETE} + # A dry run must not touch the queue. + assert await jobs.list_jobs(source_id="src") == [] + + +@pytest.mark.asyncio +async def test_dry_run_ignores_deletes_when_delete_orphans_false( + fs_config, jobs, sync, tmp_path +): + config = FSSourceConfig( + type="fs", + id="src", + root=tmp_path, + delete_orphans=False, + poll_interval_s=0.05, + ) + source = _StubSource("src", [[_event("file:///c.md", kind=SourceEventKind.DELETE)]]) + poller = _periodic(source, config, jobs, sync) + + ok, summary, changes = await poller._dry_run_once() + + assert ok is True + assert summary.delete_count == 0 + assert summary.ignored_delete_count == 1 + assert changes == [] + + +@pytest.mark.asyncio +async def test_dry_run_skipped_when_circuit_open(fs_config, jobs, sync): + class _Clock: + now = 0.0 + + def __call__(self): + return self.now + + breaker = CircuitBreaker( + CircuitBreakerConfig(failure_threshold=1, cooldown_s=30.0), + now_fn=_Clock(), + ) + source = _StubSource("src", []) + source.fail_with = RuntimeError("upstream down") + poller = _periodic(source, fs_config, jobs, sync, breaker=breaker) + + assert await poller._sweep_once() is False + assert breaker.is_open is True + + before = source.discover_calls + ok, summary, changes = await poller._dry_run_once() + + assert ok is False + assert changes == [] + assert source.discover_calls == before + assert poller.last_skip_reason == "circuit_open" + + +@pytest.mark.asyncio +async def test_dry_run_records_failure_when_discover_raises(fs_config, jobs, sync): + source = _StubSource("src", []) + source.fail_with = RuntimeError("upstream down") + poller = _periodic(source, fs_config, jobs, sync) + + ok, summary, changes = await poller._dry_run_once() + + assert ok is False + assert changes == [] + assert poller._breaker.consecutive_failures == 1 + + +@pytest.mark.asyncio +async def test_dry_run_skipped_when_queue_has_pending_work(fs_config, jobs, sync): + source = _StubSource("src", [[_event("file:///a.md")]]) + poller = _periodic(source, fs_config, jobs, sync) + await jobs.enqueue("src", "file:///pending.md", JobOp.UPSERT) + + ok, _summary, changes = await poller._dry_run_once() + + assert ok is False + assert changes == [] + assert poller.last_skip_reason == "pending_work" + + +@pytest.mark.asyncio +async def test_watch_deleted_skipped_when_delete_orphans_false(tmp_path, jobs, sync): + from watchfiles import Change + + from haiku.rag.ingester.pollers.fs import FSPoller + from haiku.rag.ingester.sources.fs import FSSource + + cfg = FSSourceConfig( + type="fs", + id="local", + root=tmp_path, + delete_orphans=False, + poll_interval_s=60.0, + ) + poller = FSPoller( + source=FSSource(root=tmp_path, supported_extensions=[".md"], source_id="local"), + config=cfg, + job_repo=jobs, + sync_repo=sync, + ) + + await poller._handle_watch_change(Change.deleted, tmp_path / "gone.md") + + assert await jobs.list_jobs(source_id="local") == [] + + +@pytest.mark.asyncio +async def test_dry_run_manifest_reports_failed_sources(tmp_path, jobs, sync): + """A source whose discover() raises is named in the failed list while the + manifest still carries the sources that succeeded.""" + manager = PollerManager( + configs=[FSSourceConfig(type="fs", id="ok", root=tmp_path)], + job_repo=jobs, + sync_repo=sync, + ) + broken = _StubSource("broken", []) + broken.fail_with = RuntimeError("upstream down") + manager._pollers.append( + _periodic( + broken, + FSSourceConfig(type="fs", id="broken", root=tmp_path, poll_interval_s=60.0), + jobs, + sync, + ) + ) + + manifest, failed = await manager.dry_run_manifest() + + assert failed == ["broken"] + assert {s.source_id for s in manifest.sources} == {"ok", "broken"} diff --git a/tests/ingester/test_webdav_source.py b/tests/ingester/test_webdav_source.py index 060ddb06..1da7e450 100644 --- a/tests/ingester/test_webdav_source.py +++ b/tests/ingester/test_webdav_source.py @@ -7,26 +7,29 @@ from haiku.rag.ingester.sources.base import FileTooLargeError, SourceEventKind from haiku.rag.ingester.sources.webdav import WebDAVSource, _strip_etag -def test_strip_etag_strong_quoted(): - assert _strip_etag('"abc123"') == "abc123" - - -def test_strip_etag_weak_marker(): - assert _strip_etag('W/"abc123"') == "abc123" - - -def test_strip_etag_unquoted(): - assert _strip_etag("abc123") == "abc123" - - -def test_strip_etag_whitespace(): - assert _strip_etag(' W/"abc" ') == "abc" - - -def test_strip_etag_empty_returns_none(): - assert _strip_etag("") is None - assert _strip_etag('""') is None - assert _strip_etag(None) is None +@pytest.mark.parametrize( + "raw,expected", + [ + ('"abc123"', "abc123"), + ('W/"abc123"', "abc123"), + ("abc123", "abc123"), + (' W/"abc" ', "abc"), + ("", None), + ('""', None), + (None, None), + ], + ids=[ + "strong_quoted", + "weak_marker", + "unquoted", + "whitespace", + "empty", + "empty_quotes", + "none", + ], +) +def test_strip_etag(raw, expected): + assert _strip_etag(raw) == expected def _transport(handler) -> httpx.MockTransport: @@ -628,3 +631,131 @@ async def test_fetch_skips_head_when_no_max_size(): ) await src.fetch("https://nc.example.com/dav/a.txt") assert calls == ["GET"] + + +# Malformed multistatus bodies: a that can't be decoded is dropped +# rather than aborting the whole listing. + + +def _raw_multistatus(*response_blocks: str) -> bytes: + body = ['', ''] + body.extend(response_blocks) + body.append("") + return "\n".join(body).encode() + + +_NO_HREF = """ + + HTTP/1.1 200 OK + "r" + + """ + +_EMPTY_HREF = """ + + + HTTP/1.1 200 OK + "r" + + """ + +_NO_STATUS = """ + /dav/a.md + + "r" + + """ + +_NOT_FOUND_STATUS = """ + /dav/a.md + + HTTP/1.1 404 Not Found + "r" + + """ + +_STATUS_WITHOUT_PROP = """ + /dav/a.md + + HTTP/1.1 200 OK + + """ + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + "block", + [_NO_HREF, _EMPTY_HREF, _NO_STATUS, _NOT_FOUND_STATUS], + ids=["no_href", "empty_href", "propstat_without_status", "propstat_404"], +) +async def test_head_returns_none_for_undecodable_response(block): + def handler(request: httpx.Request) -> httpx.Response: + return httpx.Response(207, content=_raw_multistatus(block)) + + src = WebDAVSource( + source_id="nc", + base_url="https://nc.example.com/dav/", + transport=_transport(handler), + ) + assert await src.head("https://nc.example.com/dav/a.md") is None + + +@pytest.mark.asyncio +async def test_head_returns_none_for_empty_multistatus(): + def handler(request: httpx.Request) -> httpx.Response: + return httpx.Response(207, content=_raw_multistatus()) + + src = WebDAVSource( + source_id="nc", + base_url="https://nc.example.com/dav/", + transport=_transport(handler), + ) + assert await src.head("https://nc.example.com/dav/a.md") is None + + +@pytest.mark.asyncio +async def test_entry_with_status_but_no_prop_has_no_revision(): + """A 200 propstat carrying no still yields an entry, without a revision.""" + + def handler(request: httpx.Request) -> httpx.Response: + return httpx.Response(207, content=_raw_multistatus(_STATUS_WITHOUT_PROP)) + + src = WebDAVSource( + source_id="nc", + base_url="https://nc.example.com/dav/", + transport=_transport(handler), + ) + assert await src.head("https://nc.example.com/dav/a.md") is None + + +@pytest.mark.asyncio +async def test_discover_skips_base_url_reported_as_file(): + """Broken servers list the base URL itself as a non-collection; it and any + href outside the base are skipped.""" + body = _multistatus( + {"href": "/dav/", "etag": '"base"'}, + {"href": "/outside/x.md", "etag": '"out"'}, + {"href": "/dav/keep.md", "etag": '"keep"'}, + ) + + def handler(request: httpx.Request) -> httpx.Response: + return httpx.Response(207, content=body) + + src = WebDAVSource( + source_id="nc", + base_url="https://nc.example.com/dav/", + transport=_transport(handler), + ) + events = [event async for event in src.discover()] + assert {e.uri for e in events} == {"https://nc.example.com/dav/keep.md"} + + +@pytest.mark.asyncio +async def test_aclose_closes_the_http_client(): + src = WebDAVSource( + source_id="nc", + base_url="https://nc.example.com/dav/", + transport=_transport(lambda r: httpx.Response(200)), + ) + await src.aclose() + assert src._http.is_closed diff --git a/tests/test_chunker.py b/tests/test_chunker.py index b795bdea..97b0514c 100644 --- a/tests/test_chunker.py +++ b/tests/test_chunker.py @@ -798,3 +798,78 @@ async def test_serve_chunker_accepts_picture_laden_docling(doclaynet_first_page_ chunks = await serve_chunker.chunk(doc) assert len(chunks) > 0, "docling-serve chunker returned 0 chunks" + + +class TestDoclingServeChunkerRefResolution: + """_resolve_label_from_document and the dict-shaped doc_items branch.""" + + @pytest.fixture + def chunker(self): + config = AppConfig() + config.providers.docling_serve.base_url = "http://localhost:5001" + config.processing.chunk_size = 256 + config.processing.chunking_tokenizer = "Qwen/Qwen3-Embedding-0.6B" + return DoclingServeChunker(config) + + @pytest.fixture + def document(self): + from docling_core.types.doc.document import DoclingDocument + + return DoclingDocument.model_validate( + { + "name": "doc", + "texts": [ + { + "self_ref": "#/texts/0", + "text": "body", + "orig": "body", + "label": "paragraph", + } + ], + "tables": [], + "pictures": [], + "groups": [], + "body": {"self_ref": "#/body", "children": []}, + "furniture": {"self_ref": "#/furniture", "children": []}, + } + ) + + @pytest.mark.parametrize( + "ref", + ["not-a-ref", "#/texts/999", "#/nope/0"], + ids=["unparseable", "index_out_of_range", "unknown_collection"], + ) + def test_unresolvable_ref_yields_no_label(self, document, ref): + from haiku.rag.chunkers.docling_serve import _resolve_label_from_document + + assert _resolve_label_from_document(ref, document) is None + + def test_resolvable_ref_yields_label(self, document): + from haiku.rag.chunkers.docling_serve import _resolve_label_from_document + + assert _resolve_label_from_document("#/texts/0", document) == "paragraph" + + @pytest.mark.asyncio + async def test_chunk_of_none_returns_empty(self, chunker): + assert await chunker.chunk(None) == [] + + @pytest.mark.asyncio + async def test_dict_shaped_doc_items_are_decoded(self, chunker, document): + """docling-serve returns refs as strings today; the dict shape is + accepted in case the API changes.""" + + async def fake_chunk_api(_document): + return [ + { + "raw_text": "body", + "doc_items": [{"self_ref": "#/texts/0", "label": "paragraph"}], + } + ] + + chunker._call_chunk_api = fake_chunk_api # type: ignore[method-assign] + + chunks = await chunker.chunk(document) + + assert len(chunks) == 1 + assert chunks[0].metadata["doc_item_refs"] == ["#/texts/0"] + assert chunks[0].metadata["labels"] == ["paragraph"] diff --git a/tests/test_converters.py b/tests/test_converters.py index 74518b12..9d686227 100644 --- a/tests/test_converters.py +++ b/tests/test_converters.py @@ -405,6 +405,46 @@ class TestDoclingLocalConverter: assert isinstance(doc, DoclingDocument) assert doc.name == "test" + @pytest.mark.asyncio + async def test_convert_file_reads_unknown_extension_as_text( + self, converter, tmp_path + ): + """An extension in neither the docling nor the text set is read as text.""" + source = tmp_path / "notes.xyz" + source.write_text("Plain body for an unknown extension.") + + doc = await converter.convert_file(source) + + assert isinstance(doc, DoclingDocument) + assert "Plain body for an unknown extension." in doc.export_to_markdown() + + @pytest.mark.asyncio + async def test_convert_file_raises_for_undecodable_file(self, converter, tmp_path): + source = tmp_path / "binary.xyz" + source.write_bytes(b"\xff\xfe\x00\x01 not utf-8") + + with pytest.raises(ValueError, match="Failed to parse file"): + await converter.convert_file(source) + + @pytest.mark.asyncio + async def test_convert_text_wraps_conversion_failure(self, converter, monkeypatch): + def boom(*_args, **_kwargs): + raise RuntimeError("docling exploded") + + monkeypatch.setattr(converter, "_sync_convert_docling_text", boom) + + with pytest.raises(ValueError, match="Failed to convert text"): + await converter.convert_text("# Test", name="test.md") + + @pytest.mark.asyncio + async def test_convert_text_falls_back_when_format_not_inferable(self, converter): + """docling raises ConversionError for an extension it has no backend + for; the simple-document fallback keeps the text.""" + doc = await converter.convert_text("just some prose", name="mystery.zzz") + + assert isinstance(doc, DoclingDocument) + assert "just some prose" in doc.export_to_markdown() + @pytest.mark.asyncio async def test_convert_code_file(self, converter): """Test that code files are wrapped in code blocks.""" @@ -1522,3 +1562,121 @@ class TestDoclingServeConverterIntegration: assert str(sample.image.uri).startswith("data:image/"), ( "Rehydrated picture URI should be a data: URI, not a bare artifact filename" ) + + +class TestDoclingServeZipParsing: + """_parse_zip_to_docling decodes the target_type=zip payload. These drive + its branches directly — no docling-serve instance involved.""" + + @pytest.fixture + def converter(self): + config = AppConfig() + config.processing.converter = "docling-serve" + conv = get_converter(config) + assert isinstance(conv, DoclingServeConverter) + return conv + + @staticmethod + def _zip(entries: dict[str, bytes]) -> bytes: + import io + import zipfile + + buf = io.BytesIO() + with zipfile.ZipFile(buf, mode="w") as zf: + for name, blob in entries.items(): + zf.writestr(name, blob) + return buf.getvalue() + + @staticmethod + def _doc_json(**extra) -> dict: + base = { + "name": "document", + "texts": [], + "tables": [], + "pictures": [], + "groups": [], + "body": {"self_ref": "#/body", "children": []}, + "furniture": {"self_ref": "#/furniture", "children": []}, + } + base.update(extra) + return base + + def test_raises_without_top_level_json(self, converter): + blob = self._zip({"artifacts/image.png": b"png"}) + + with pytest.raises(ValueError, match="no top-level JSON document"): + converter._parse_zip_to_docling(blob, "doc.pdf") + + def test_picture_without_image_is_left_alone(self, converter): + import json as _json + + doc_json = self._doc_json( + pictures=[ + { + "self_ref": "#/pictures/0", + "label": "picture", + "image": None, + "prov": [], + } + ] + ) + blob = self._zip({"document.json": _json.dumps(doc_json).encode()}) + + doc = converter._parse_zip_to_docling(blob, "doc.pdf") + + assert doc.pictures[0].image is None + + def test_data_uri_image_is_passed_through(self, converter): + import json as _json + + data_uri = "data:image/png;base64,aGVsbG8=" + doc_json = self._doc_json( + pictures=[ + { + "self_ref": "#/pictures/0", + "label": "picture", + "image": { + "mimetype": "image/png", + "dpi": 72, + "size": {"width": 1, "height": 1}, + "uri": data_uri, + }, + "prov": [], + } + ] + ) + blob = self._zip({"document.json": _json.dumps(doc_json).encode()}) + + doc = converter._parse_zip_to_docling(blob, "doc.pdf") + + assert str(doc.pictures[0].image.uri) == data_uri + + def test_non_dict_page_entry_is_skipped_while_inlining(self, converter): + """A page entry that isn't an object must not blow up the image-inlining + loop with an AttributeError; it falls through to schema validation.""" + import json as _json + + from pydantic import ValidationError + + doc_json = self._doc_json(pages={"1": "not-a-page-object"}) + blob = self._zip({"document.json": _json.dumps(doc_json).encode()}) + + with pytest.raises(ValidationError): + converter._parse_zip_to_docling(blob, "doc.pdf") + + @pytest.mark.asyncio + async def test_convert_text_rejects_unsupported_format(self, converter): + with pytest.raises(ValueError, match="Unsupported format"): + await converter.convert_text("body", format="pdf") + + @pytest.mark.asyncio + async def test_convert_text_plain_builds_document_locally(self, converter): + """format="plain" never reaches the network.""" + converter.client.submit_and_poll_zip = AsyncMock( # ty: ignore[invalid-assignment] + side_effect=AssertionError("must not call docling-serve") + ) + + doc = await converter.convert_text("just text", format="plain") + + assert isinstance(doc, DoclingDocument) + assert "just text" in doc.export_to_markdown() diff --git a/tests/test_docling_serve_client.py b/tests/test_docling_serve_client.py index ceaf89ee..175ed53e 100644 --- a/tests/test_docling_serve_client.py +++ b/tests/test_docling_serve_client.py @@ -481,3 +481,29 @@ def test_from_config_wires_retry_and_breaker(): assert client._max_attempts == 7 assert client._breaker_config.failure_threshold == 9 assert client._breaker_config.cooldown_s == 90.0 + + +@pytest.mark.asyncio +async def test_submit_without_task_id_raises(): + """A 200 that carries no task_id is a protocol violation, not a silent pass.""" + import httpx + + from haiku.rag.providers.docling_serve import DoclingServeClient + + def handler(request: httpx.Request) -> httpx.Response: + return httpx.Response(200, json={}) + + client = DoclingServeClient(base_urls="http://docling:5001") + files = {"files": ("doc.pdf", b"pdf", "application/octet-stream")} + + async with httpx.AsyncClient(transport=httpx.MockTransport(handler)) as http: + with pytest.raises(ValueError, match="did not return a task_id"): + await client._submit_and_wait( + http, + "http://docling:5001", + "/v1/convert/source/async", + files, + {}, + {}, + "doc.pdf", + ) diff --git a/tests/test_embedder_config.py b/tests/test_embedder_config.py index a8a37fde..ce7561ff 100644 --- a/tests/test_embedder_config.py +++ b/tests/test_embedder_config.py @@ -148,3 +148,47 @@ def test_vllm_embedder_does_not_double_append_v1(): base_url = embedder._base_url.rstrip("/") # type: ignore[attr-defined] # ty: ignore[unresolved-attribute] assert base_url.endswith("/v1") assert not base_url.endswith("/v1/v1") + + +def test_vector_dim_property_reports_configured_dimension(): + from haiku.rag.embeddings import EmbedderWrapper + + assert EmbedderWrapper(embedder=None, vector_dim=512).vector_dim == 512 + + +@pytest.mark.parametrize( + "provider,env_var", + [("voyageai", "VOYAGE_API_KEY"), ("cohere", "CO_API_KEY")], +) +def test_saas_providers_build_offline(monkeypatch, provider, env_var): + """Construction only wires the SDK; no request is made.""" + monkeypatch.setenv(env_var, "test-key") + config = AppConfig( + embeddings=EmbeddingsConfig( + model=EmbeddingModelConfig( + provider=provider, name="some-model", vector_dim=1024 + ), + ), + ) + + embedder = get_embedder(config) + + assert embedder.vector_dim == 1024 + + +def test_cohere_floats_rejects_missing_embeddings(): + from types import SimpleNamespace + + from haiku.rag.embeddings.cohere import _floats + + result = SimpleNamespace(embeddings=SimpleNamespace(float_=None)) + + with pytest.raises(ValueError, match="no float embeddings"): + _floats(result) + + +def test_voyageai_to_pil_rejects_unsupported_type(): + from haiku.rag.embeddings.voyageai import _to_pil + + with pytest.raises(TypeError, match="Unsupported image type"): + _to_pil("not an image") # ty: ignore[invalid-argument-type] diff --git a/tests/test_mcp.py b/tests/test_mcp.py index eda2e2e2..f0c36474 100644 --- a/tests/test_mcp.py +++ b/tests/test_mcp.py @@ -332,3 +332,152 @@ class TestMCPImageInput: result = await ask(question="q") assert result == "answer" assert captured["images"] is None + + +class TestMCPFileAndUrlIngestion: + @pytest.mark.asyncio + async def test_add_document_from_file(self, temp_db_path, tmp_path): + async with HaikuRAG(temp_db_path, create=True): + pass + source = tmp_path / "note.txt" + source.write_text("Ingested from a file path.") + + mcp = create_mcp_server(temp_db_path, read_only=False) + add_file = await _get_tool(mcp, "add_document_from_file") + + doc_id = await add_file(file_path=str(source), title="File Doc") + assert doc_id is not None + + get_doc = await _get_tool(mcp, "get_document") + doc = await get_doc(document_id=doc_id) + assert doc.title == "File Doc" + + @pytest.mark.asyncio + @pytest.mark.parametrize( + "tool_name,kwargs", + [ + ("add_document_from_file", {"file_path": "/tmp/x.txt"}), + ("add_document_from_url", {"url": "https://example.com/x.txt"}), + ], + ) + @pytest.mark.parametrize( + "results,expected", + [ + ( + [Document(id="first", content="a"), Document(id="second", content="b")], + "first", + ), + ([], None), + ], + ids=["directory_reports_first_id", "empty_directory_reports_none"], + ) + async def test_add_tools_handle_multi_document_sources( + self, mcp_db, monkeypatch, tool_name, kwargs, results, expected + ): + """A source resolving to several documents reports the first id.""" + + async def fake_from_source(self, source, title=None, metadata=None, **kw): + return results + + monkeypatch.setattr(HaikuRAG, "create_document_from_source", fake_from_source) + mcp = create_mcp_server(mcp_db, read_only=False) + add = await _get_tool(mcp, tool_name) + + assert await add(**kwargs) == expected + + @pytest.mark.asyncio + async def test_add_document_from_url(self, mcp_db, monkeypatch): + async def fake_from_source(self, source, title=None, metadata=None, **kwargs): + assert source == "https://example.com/doc.txt" + return Document(id="url-doc", content="fetched") + + monkeypatch.setattr(HaikuRAG, "create_document_from_source", fake_from_source) + mcp = create_mcp_server(mcp_db, read_only=False) + add_url = await _get_tool(mcp, "add_document_from_url") + + assert await add_url(url="https://example.com/doc.txt") == "url-doc" + + +class TestMCPToolsDegradeOnError: + """Every tool swallows client failures and returns its empty value rather + than propagating an exception to the MCP transport.""" + + @pytest.mark.asyncio + @pytest.mark.parametrize( + "client_method,tool_name,kwargs,expected", + [ + ( + "create_document_from_source", + "add_document_from_file", + {"file_path": "/tmp/x.txt"}, + None, + ), + ( + "create_document_from_source", + "add_document_from_url", + {"url": "https://example.com/x"}, + None, + ), + ("create_document", "add_document_from_text", {"content": "x"}, None), + ("delete_document", "delete_document", {"document_id": "x"}, False), + ("search", "search_documents", {"query": "x"}, []), + ("get_document_by_id", "get_document", {"document_id": "x"}, None), + ("list_documents", "list_documents", {}, []), + ], + ) + async def test_tool_returns_empty_value_when_client_raises( + self, mcp_db, monkeypatch, client_method, tool_name, kwargs, expected + ): + async def boom(self, *args, **kw): + raise RuntimeError("client exploded") + + monkeypatch.setattr(HaikuRAG, client_method, boom) + mcp = create_mcp_server(mcp_db, read_only=False) + tool = await _get_tool(mcp, tool_name) + + assert await tool(**kwargs) == expected + + @pytest.mark.asyncio + async def test_list_documents_returns_empty_for_invalid_filter(self, mcp_db): + mcp = create_mcp_server(mcp_db, read_only=True) + list_docs = await _get_tool(mcp, "list_documents") + + assert await list_docs(filter="no_such_column = 1") == [] + + @pytest.mark.asyncio + async def test_analyze_reports_the_error(self, mcp_db, monkeypatch): + async def boom(self, question, filter=None, images=None): + raise RuntimeError("sandbox exploded") + + monkeypatch.setattr(HaikuRAG, "analyze", boom) + mcp = create_mcp_server(mcp_db, read_only=True) + analyze = await _get_tool(mcp, "analyze") + + assert "sandbox exploded" in await analyze(question="q") + + @pytest.mark.asyncio + async def test_ask_question_appends_citations_when_requested( + self, mcp_db, monkeypatch + ): + from haiku.rag.store.models.citation import Citation + + citation = Citation( + chunk_id="c1", + document_id="d1", + content="cited text", + document_uri="test://ai-overview", + document_title="AI Overview", + ) + + async def fake_ask(self, question, filter=None, images=None): + return ("the answer", [citation]) + + monkeypatch.setattr(HaikuRAG, "ask", fake_ask) + mcp = create_mcp_server(mcp_db, read_only=True) + ask = await _get_tool(mcp, "ask_question") + + with_cite = await ask(question="q", cite=True) + assert with_cite.startswith("the answer") + assert "AI Overview" in with_cite + + assert await ask(question="q", cite=False) == "the answer" diff --git a/tests/test_pdf_split.py b/tests/test_pdf_split.py index 09b3f274..af5abaf9 100644 --- a/tests/test_pdf_split.py +++ b/tests/test_pdf_split.py @@ -243,3 +243,14 @@ def test_concatenate_shifts_page_nos_and_unique_self_refs(): assert page_nos == [1, 2], f"expected b's page 1 to shift to page 2, got {page_nos}" assert sorted(merged.pages.keys()) == [1, 2] + + +def test_iter_pdf_slices_rejects_unopenable_pdf(tmp_path): + """pdfium refuses non-PDF bytes; the caller sees UnsupportedSourceError.""" + from haiku.rag.client.exceptions import UnsupportedSourceError + + junk = tmp_path / "not-really.pdf" + junk.write_bytes(b"this is not a pdf at all") + + with pytest.raises(UnsupportedSourceError, match="cannot open PDF"): + list(iter_pdf_slices(junk, slice_size=1)) diff --git a/tests/test_reranker.py b/tests/test_reranker.py index 0f8c77bf..635fe5fc 100644 --- a/tests/test_reranker.py +++ b/tests/test_reranker.py @@ -479,3 +479,30 @@ async def test_cross_encoder_reranker(): assert "0" in top_ids or "2" in top_ids except ImportError: pytest.skip("sentence-transformers not installed") + + +@pytest.mark.asyncio +async def test_cross_encoder_reranks_via_model_ranking(monkeypatch): + """The rank() results map back onto the input chunks by corpus_id.""" + from haiku.rag.reranking import cross_encoder as ce_module + + class _StubCrossEncoder: + def __init__(self, model): + self.model = model + + def rank(self, query, documents, top_k=10): + # Reverse order so the mapping back to chunks is observable. + return [ + {"corpus_id": i, "score": 1.0 - (i / 10)} + for i in reversed(range(len(documents))) + ][:top_k] + + monkeypatch.setattr(ce_module, "CrossEncoder", _StubCrossEncoder) + + reranker = ce_module.CrossEncoderReranker("stub/model") + reranked = await reranker.rerank("query", chunks, top_n=2) + + assert len(reranked) == 2 + last_index = len(chunks) - 1 + assert reranked[0][0] is chunks[last_index] + assert reranked[0][1] == pytest.approx(1.0 - last_index / 10) From 7c76c3399eee4a3ecd3b57f086ca61de5e6120dc Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Sun, 26 Jul 2026 19:23:54 +0300 Subject: [PATCH 04/16] Cover get_model provider branches and visualize_chunk edge paths Parametrize the get_model tests whose only assertion was the returned model type, extending the table to the reasoning-off, groq-parsed and Bedrock o-series/qwen/unmapped branches. Fold format_citations_no_title into the superset test that already covered its scenario. Add tests for cosine_similarity on parallel vectors, multi-citation Rich rendering, picture rendering with missing and undecodable bytes, a missing docling distribution, and the visualize_chunk short-circuits for absent documents, absent rasters and refless chunks. --- tests/test_client.py | 239 +++++++++++++++++++++++++++++++++++++++++++ tests/test_search.py | 67 +++++++++++- tests/test_utils.py | 209 ++++++++++++++++++++++++------------- 3 files changed, 441 insertions(+), 74 deletions(-) diff --git a/tests/test_client.py b/tests/test_client.py index 73012dc5..fe545765 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -2279,3 +2279,242 @@ def test_check_source_accessible_file_uri(tmp_path): assert check_source_accessible(existing.as_uri()) is True assert check_source_accessible((tmp_path / "gone.txt").as_uri()) is False + + +def _bbox_doc(*, with_page_image: bool, pages: tuple[int, ...] = (1,)): + """DoclingDocument with one paragraph per page, each carrying a bbox. + + ``with_page_image=False`` produces pages with no raster, so bounding boxes + resolve but there is nothing to draw them on. + """ + from docling_core.types.doc.base import BoundingBox, Size + from docling_core.types.doc.document import ImageRef, ProvenanceItem + from PIL import Image as PilImageModule + + doc = DoclingDocument(name="bbox-doc") + size = Size(width=612.0, height=792.0) + for page_no in pages: + image = ( + ImageRef.from_pil( + PilImageModule.new("RGB", (612, 792), color="white"), dpi=72 + ) + if with_page_image + else None + ) + doc.add_page(page_no=page_no, size=size, image=image) + doc.add_text( + label=DocItemLabel.PARAGRAPH, + text=f"Content on page {page_no}.", + prov=ProvenanceItem( + page_no=page_no, + bbox=BoundingBox(l=50, t=700, r=550, b=650), + charspan=(0, 20), + ), + ) + return doc + + +@pytest.mark.asyncio +async def test_visualize_chunk_returns_empty_without_page_rasters(temp_db_path): + """Boxes resolve, but a document ingested without page images has nothing + to render them onto.""" + docling_doc = _bbox_doc(with_page_image=False) + chunks = [ + Chunk( + content="Content on page 1.", + metadata={ + "doc_item_refs": ["#/texts/0"], + "page_numbers": [1], + "labels": ["paragraph"], + }, + order=0, + embedding=[0.1] * 2560, + ) + ] + + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.import_document(docling_doc, chunks, uri="test://no-raster") + stored = await client.chunk_repository.get_by_document_id(doc.id) + + assert await client.visualize_chunk(stored[0]) == [] + + +@pytest.mark.asyncio +async def test_visualize_chunk_skips_pages_without_a_raster(temp_db_path): + """A document where only some pages carry a raster renders just those.""" + from docling_core.types.doc.base import BoundingBox, Size + from docling_core.types.doc.document import ImageRef, ProvenanceItem + from PIL import Image as PilImageModule + + docling_doc = DoclingDocument(name="mixed-rasters") + size = Size(width=612.0, height=792.0) + docling_doc.add_page( + page_no=1, + size=size, + image=ImageRef.from_pil( + PilImageModule.new("RGB", (612, 792), color="white"), dpi=72 + ), + ) + docling_doc.add_page(page_no=2, size=size, image=None) + for page_no in (1, 2): + docling_doc.add_text( + label=DocItemLabel.PARAGRAPH, + text=f"Content on page {page_no}.", + prov=ProvenanceItem( + page_no=page_no, + bbox=BoundingBox(l=50, t=700, r=550, b=650), + charspan=(0, 20), + ), + ) + + chunks = [ + Chunk( + content="Content on page 1.\nContent on page 2.", + metadata={ + "doc_item_refs": ["#/texts/0", "#/texts/1"], + "page_numbers": [1, 2], + "labels": ["paragraph", "paragraph"], + }, + order=0, + embedding=[0.1] * 2560, + ) + ] + + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.import_document( + docling_doc, chunks, uri="test://mixed-rasters" + ) + stored = await client.chunk_repository.get_by_document_id(doc.id) + + images = await client.visualize_chunk(stored[0]) + + assert len(images) == 1 + + +@pytest.mark.asyncio +async def test_visualize_chunk_returns_empty_when_pages_row_missing(temp_db_path): + docling_doc = _bbox_doc(with_page_image=True) + chunks = [ + Chunk( + content="Content on page 1.", + metadata={ + "doc_item_refs": ["#/texts/0"], + "page_numbers": [1], + "labels": ["paragraph"], + }, + order=0, + embedding=[0.1] * 2560, + ) + ] + + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.import_document(docling_doc, chunks, uri="test://no-row") + stored = await client.chunk_repository.get_by_document_id(doc.id) + + async def no_pages_row(document_id): + return None + + client.document_repository.get_pages_data = no_pages_row # type: ignore[method-assign] + + assert await client.visualize_chunk(stored[0]) == [] + + +@pytest.mark.asyncio +async def test_visualize_chunk_skips_box_on_unstored_page(temp_db_path): + """A bounding box referencing a page the document never registered is + skipped rather than raising.""" + from docling_core.types.doc.base import BoundingBox, Size + from docling_core.types.doc.document import ImageRef, ProvenanceItem + from PIL import Image as PilImageModule + + docling_doc = DoclingDocument(name="orphan-page-box") + docling_doc.add_page( + page_no=1, + size=Size(width=612.0, height=792.0), + image=ImageRef.from_pil( + PilImageModule.new("RGB", (612, 792), color="white"), dpi=72 + ), + ) + docling_doc.add_text( + label=DocItemLabel.PARAGRAPH, + text="Content attributed to a page with no raster.", + prov=ProvenanceItem( + page_no=3, + bbox=BoundingBox(l=50, t=700, r=550, b=650), + charspan=(0, 20), + ), + ) + + chunks = [ + Chunk( + content="Content attributed to a page with no raster.", + metadata={ + "doc_item_refs": ["#/texts/0"], + "page_numbers": [3], + "labels": ["paragraph"], + }, + order=0, + embedding=[0.1] * 2560, + ) + ] + + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.import_document( + docling_doc, chunks, uri="test://orphan-page" + ) + stored = await client.chunk_repository.get_by_document_id(doc.id) + + assert await client.visualize_chunk(stored[0]) == [] + + +@pytest.mark.asyncio +async def test_visualize_chunk_without_refs_falls_back_to_chunk_metadata(temp_db_path): + """A chunk carrying no doc_item_refs has nothing to expand from.""" + docling_doc = _bbox_doc(with_page_image=True) + chunks = [ + Chunk( + content="Content on page 1.", + metadata={"page_numbers": [1], "labels": ["paragraph"]}, + order=0, + embedding=[0.1] * 2560, + ) + ] + + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.import_document(docling_doc, chunks, uri="test://no-refs") + stored = await client.chunk_repository.get_by_document_id(doc.id) + + assert await client.visualize_chunk(stored[0]) == [] + + +@pytest.mark.asyncio +async def test_visualize_chunk_falls_back_when_expansion_drops_refs(temp_db_path): + """If expansion returns results carrying no refs, the original search + results' refs are used instead.""" + from haiku.rag.client import search as search_module + + docling_doc = _bbox_doc(with_page_image=True) + chunks = [ + Chunk( + content="Content on page 1.", + metadata={ + "doc_item_refs": ["#/texts/0"], + "page_numbers": [1], + "labels": ["paragraph"], + }, + order=0, + embedding=[0.1] * 2560, + ) + ] + + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.import_document(docling_doc, chunks, uri="test://drops-refs") + stored = await client.chunk_repository.get_by_document_id(doc.id) + + async def expansion_without_refs(_client, results): + return [r.model_copy(update={"doc_item_refs": []}) for r in results] + + with patch.object(search_module, "expand_context", expansion_without_refs): + images = await client.visualize_chunk(stored[0]) + + assert len(images) == 1 diff --git a/tests/test_search.py b/tests/test_search.py index 982b44f8..6a6e429f 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -480,20 +480,26 @@ def _picture_only_result( ) -def test_dedup_keeps_higher_scoring_picture_chunk(): +@pytest.mark.parametrize( + "first_score,second_score", + # Whichever duplicate scores higher wins, regardless of arrival order. + [(0.7, 0.9), (0.9, 0.7)], + ids=["later_wins", "earlier_wins"], +) +def test_dedup_keeps_higher_scoring_picture_chunk(first_score, second_score): """Two results referencing the same single picture self_ref collapse to the one with the higher score.""" from haiku.rag.client.search import _dedup_picture_chunks - text_chunk = _picture_only_result("#/pictures/0", score=0.7) - pic_chunk = _picture_only_result("#/pictures/0", score=0.9) + text_chunk = _picture_only_result("#/pictures/0", score=first_score) + pic_chunk = _picture_only_result("#/pictures/0", score=second_score) other = _picture_only_result("#/pictures/1", score=0.6) deduped = _dedup_picture_chunks([text_chunk, pic_chunk, other]) assert len(deduped) == 2 chosen = next(r for r in deduped if r.doc_item_refs == ["#/pictures/0"]) - assert chosen.score == 0.9 + assert chosen.score == max(first_score, second_score) assert any(r.doc_item_refs == ["#/pictures/1"] for r in deduped) @@ -525,3 +531,56 @@ def test_dedup_does_not_collapse_across_documents(): deduped = _dedup_picture_chunks([a, b]) assert len(deduped) == 2 + + +# visualize_chunk short-circuits + + +@pytest.mark.asyncio +async def test_expand_context_passes_through_results_without_document(temp_db_path): + """A result with no document_id can't be expanded; it is returned as-is.""" + from haiku.rag.client.search import expand_context + + async with HaikuRAG(temp_db_path, create=True) as rag: + orphan = SearchResult(content="loose text", score=0.5, chunk_id="c1") + assert await expand_context(rag, [orphan]) == [orphan] + + +@pytest.mark.asyncio +async def test_visualize_chunk_returns_empty_for_no_chunks(temp_db_path): + async with HaikuRAG(temp_db_path, create=True) as rag: + assert await rag.visualize_chunk([]) == [] + + +@pytest.mark.asyncio +async def test_visualize_chunk_returns_empty_without_document_id(temp_db_path): + from haiku.rag.store.models.chunk import Chunk + + async with HaikuRAG(temp_db_path, create=True) as rag: + assert await rag.visualize_chunk(Chunk(content="x", metadata={})) == [] + + +@pytest.mark.asyncio +async def test_visualize_chunk_returns_empty_when_document_missing(temp_db_path): + from haiku.rag.store.models.chunk import Chunk + + async with HaikuRAG(temp_db_path, create=True) as rag: + chunk = Chunk(content="x", document_id="does-not-exist", metadata={}) + assert await rag.visualize_chunk(chunk) == [] + + +@pytest.mark.asyncio +async def test_visualize_chunk_returns_empty_when_docling_blob_absent(temp_db_path): + """A markdown-ingested document has no docling structure to resolve boxes in.""" + from haiku.rag.store.models.chunk import Chunk + from haiku.rag.store.models.document import Document + from haiku.rag.store.repositories.document import DocumentRepository + + async with HaikuRAG(temp_db_path, create=True) as rag: + doc = await DocumentRepository(rag.store).create( + Document(content="plain body", uri="test://plain") + ) + assert doc.id is not None + chunk = Chunk(content="plain body", document_id=doc.id, metadata={}) + + assert await rag.visualize_chunk(chunk) == [] diff --git a/tests/test_utils.py b/tests/test_utils.py index 01809e2b..7ecbf13c 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -139,27 +139,38 @@ Emoji test: 🚀 ✅ 📝""" assert "🚀" in result_markdown -def test_get_model_ollama(): - """Test get_model returns OpenAIChatModel for Ollama.""" - model_config = ModelConfig(provider="ollama", name="llama3") - result = get_model(model_config) - assert isinstance(result, OpenAIChatModel) - - -def test_get_model_ollama_without_thinking(): - """Test get_model configures thinking for gpt-oss on Ollama.""" - model_config = ModelConfig(provider="ollama", name="gpt-oss", enable_thinking=False) - result = get_model(model_config) - assert isinstance(result, OpenAIChatModel) - - -def test_get_model_ollama_with_settings(): - """Test get_model applies temperature and max_tokens for Ollama.""" - model_config = ModelConfig( - provider="ollama", name="llama3", temperature=0.5, max_tokens=100 - ) - result = get_model(model_config) - assert isinstance(result, OpenAIChatModel) +@pytest.mark.parametrize( + "kwargs", + [ + {"provider": "ollama", "name": "llama3"}, + {"provider": "ollama", "name": "gpt-oss", "enable_thinking": False}, + {"provider": "ollama", "name": "gpt-oss", "enable_thinking": True}, + {"provider": "ollama", "name": "llama3", "temperature": 0.5, "max_tokens": 100}, + {"provider": "openai", "name": "gpt-4o"}, + {"provider": "openai", "name": "o1", "enable_thinking": True}, + {"provider": "openai", "name": "o1", "enable_thinking": False}, + { + "provider": "openai", + "name": "gpt-4o", + "enable_thinking": False, + "temperature": 0.7, + "max_tokens": 500, + }, + ], + ids=[ + "ollama", + "ollama_thinking_off", + "ollama_thinking_on", + "ollama_with_settings", + "openai", + "openai_reasoning_thinking_on", + "openai_reasoning_thinking_off", + "openai_all_settings", + ], +) +def test_get_model_returns_openai_chat_model(kwargs): + """Every ollama and openai configuration resolves to an OpenAIChatModel.""" + assert isinstance(get_model(ModelConfig(**kwargs)), OpenAIChatModel) def test_get_model_ollama_appends_v1_to_per_model_base_url(): @@ -183,20 +194,6 @@ def test_get_model_ollama_does_not_double_append_v1(): assert not url.endswith("/v1/v1") -def test_get_model_openai(): - """Test get_model returns OpenAIChatModel for OpenAI.""" - model_config = ModelConfig(provider="openai", name="gpt-4o") - result = get_model(model_config) - assert isinstance(result, OpenAIChatModel) - - -def test_get_model_openai_with_thinking(): - """Test get_model configures thinking for OpenAI reasoning models.""" - model_config = ModelConfig(provider="openai", name="o1", enable_thinking=True) - result = get_model(model_config) - assert isinstance(result, OpenAIChatModel) - - def test_get_model_openai_non_reasoning_model_ignores_thinking(): """Test that non-reasoning OpenAI models don't get reasoning_effort setting.""" model_config = ModelConfig( @@ -299,14 +296,15 @@ def test_get_model_anthropic(): @pytest.mark.skipif(not HAS_ANTHROPIC, reason="Anthropic not installed") -def test_get_model_anthropic_with_thinking(): +@pytest.mark.parametrize("enable_thinking", [True, False]) +def test_get_model_anthropic_with_thinking(enable_thinking): """Test get_model configures thinking for Anthropic.""" from pydantic_ai.models.anthropic import AnthropicModel model_config = ModelConfig( provider="anthropic", name="claude-3-5-sonnet-20241022", - enable_thinking=True, + enable_thinking=enable_thinking, ) result = get_model(model_config) assert isinstance(result, AnthropicModel) @@ -345,12 +343,15 @@ def test_get_model_groq(): @pytest.mark.skipif(not HAS_GROQ, reason="Groq not installed") -def test_get_model_groq_with_thinking(): +@pytest.mark.parametrize("enable_thinking", [True, False]) +def test_get_model_groq_with_thinking(enable_thinking): """Test get_model configures thinking format for Groq.""" from pydantic_ai.models.groq import GroqModel model_config = ModelConfig( - provider="groq", name="llama-3.3-70b-versatile", enable_thinking=False + provider="groq", + name="llama-3.3-70b-versatile", + enable_thinking=enable_thinking, ) result = get_model(model_config) assert isinstance(result, GroqModel) @@ -369,14 +370,26 @@ def test_get_model_bedrock(): @pytest.mark.skipif(not HAS_BEDROCK, reason="Bedrock not installed") -def test_get_model_bedrock_with_thinking(): - """Test get_model configures thinking for Bedrock Claude models.""" +@pytest.mark.parametrize("enable_thinking", [True, False]) +@pytest.mark.parametrize( + "name", + [ + "anthropic.claude-3-5-sonnet-20241022-v2:0", + "openai.o3-mini-v1:0", + "qwen.qwen3-32b-v1:0", + # A family with no reasoning mapping leaves the request fields untouched. + "meta.llama3-70b-instruct-v1:0", + ], + ids=["claude", "o_series", "qwen", "unmapped_family"], +) +def test_get_model_bedrock_with_thinking(name, enable_thinking): + """Each Bedrock model family maps thinking onto its own request field.""" from pydantic_ai.models.bedrock import BedrockConverseModel model_config = ModelConfig( provider="bedrock", - name="anthropic.claude-3-5-sonnet-20241022-v2:0", - enable_thinking=True, + name=name, + enable_thinking=enable_thinking, ) result = get_model(model_config) assert isinstance(result, BedrockConverseModel) @@ -390,19 +403,6 @@ def test_get_model_unknown_provider(): assert result == "mistral:mistral-large-latest" -def test_get_model_with_all_settings(): - """Test get_model applies all settings together.""" - model_config = ModelConfig( - provider="openai", - name="gpt-4o", - enable_thinking=False, - temperature=0.7, - max_tokens=500, - ) - result = get_model(model_config) - assert isinstance(result, OpenAIChatModel) - - def test_get_package_versions(): """Test get_package_versions returns expected keys.""" from haiku.rag.utils import get_package_versions @@ -526,20 +526,7 @@ def test_format_citations_multiple_pages(): result = format_citations([citation]) assert "[1] test://doc" in result assert "pp. 1-3" in result - - -def test_format_citations_no_title(): - from haiku.rag.store.models.citation import Citation - from haiku.rag.utils import format_citations - - citation = Citation( - document_id="doc1", - chunk_id="chunk1", - document_uri="test://doc", - content="Content", - ) - result = format_citations([citation]) - assert "[1] test://doc" in result + # No title: the URI stands in, and the document id never leaks. assert "doc1" not in result @@ -758,3 +745,85 @@ def test_parse_model_option(): for bad in ["just-a-name", ":model", "provider:"]: with pytest.raises(ValueError, match="Invalid model format"): parse_model_option(bad) + + +def test_cosine_similarity_identical_vectors(): + from haiku.rag.utils import cosine_similarity + + assert cosine_similarity([1.0, 0.0], [1.0, 0.0]) == pytest.approx(1.0) + assert cosine_similarity([1.0, 0.0], [0.0, 1.0]) == pytest.approx(0.0) + + +async def test_format_citations_rich_separates_multiple_citations(): + from haiku.rag.store.models.citation import Citation + from haiku.rag.utils import format_citations_rich + + citations = [ + Citation( + document_id=f"doc{i}", + chunk_id=f"chunk{i}", + document_uri=f"test://doc{i}", + document_title=f"Doc {i}", + content=f"Body {i}", + ) + for i in (1, 2) + ] + + output = _render_rich(await format_citations_rich(citations)) + + assert "[1] Doc 1 (test://doc1)" in output + assert "[2] Doc 2 (test://doc2)" in output + + +@pytest.mark.parametrize( + "stored,renders", + [ + (None, False), + (b"not a real image", False), + ("png", True), + ], + ids=["no_bytes", "undecodable_bytes", "valid_png"], +) +async def test_render_picture_handles_stored_bytes(stored, renders): + from unittest.mock import AsyncMock + + from haiku.rag.utils import _render_picture + + if stored == "png": + from io import BytesIO + + from PIL import Image as PILImage + + buf = BytesIO() + PILImage.new("RGB", (4, 4), "red").save(buf, format="PNG") + stored = buf.getvalue() + + client = AsyncMock() + client.document_item_repository.get_picture_bytes = AsyncMock(return_value=stored) + + result = await _render_picture(client, "doc1", "#/pictures/0") + + assert (result is not None) is renders + + +async def test_render_picture_without_client_returns_none(): + from haiku.rag.utils import _render_picture + + assert await _render_picture(None, "doc1", "#/pictures/0") is None + + +def test_get_package_versions_reports_missing_docling(monkeypatch): + from importlib import metadata as importlib_metadata + + from haiku.rag.utils import get_package_versions + + real_version = importlib_metadata.version + + def fake_version(name): + if name == "docling": + raise importlib_metadata.PackageNotFoundError(name) + return real_version(name) + + monkeypatch.setattr(importlib_metadata, "version", fake_version) + + assert get_package_versions()["docling"] == "not installed" From dc5ad8f6995107747462dfddff581fd2b044488c Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Sun, 26 Jul 2026 19:32:09 +0300 Subject: [PATCH 05/16] Cover the rebuild paths Add tests for the vacuum-failure warning, documents deleted mid-rebuild, chunkless documents, batch flushes in the embed-only, descriptions and full paths, a missing docling blob under rechunk, missing and recoverable picture bytes, and the source-missing fallback. Direct-call tests cover the staging helpers and the idempotent phase-1 marker. --- ...build_descriptions_flushes_in_batches.yaml | 86 ++++ ...rebuild_embed_only_flushes_in_batches.yaml | 242 +++++++++++ ...y_recovers_picture_bytes[recoverable].yaml | 42 ++ ...ed_only_recovers_picture_bytes[wiped].yaml | 46 +++ ..._only_yields_documents_without_chunks.yaml | 42 ++ .../test_rebuild_full_flushes_in_batches.yaml | 242 +++++++++++ ...flushes_pending_before_source_rebuild.yaml | 162 ++++++++ ...ll_skips_document_deleted_mid_rebuild.yaml | 42 ++ ...ild_full_warns_when_source_is_missing.yaml | 82 ++++ ..._warns_when_post_rebuild_vacuum_fails.yaml | 82 ++++ ...k_raises_when_docling_blob_is_missing.yaml | 42 ++ tests/test_rebuild.py | 380 ++++++++++++++++++ 12 files changed, 1490 insertions(+) create mode 100644 tests/cassettes/test_rebuild/test_rebuild_descriptions_flushes_in_batches.yaml create mode 100644 tests/cassettes/test_rebuild/test_rebuild_embed_only_flushes_in_batches.yaml create mode 100644 tests/cassettes/test_rebuild/test_rebuild_embed_only_recovers_picture_bytes[recoverable].yaml create mode 100644 tests/cassettes/test_rebuild/test_rebuild_embed_only_recovers_picture_bytes[wiped].yaml create mode 100644 tests/cassettes/test_rebuild/test_rebuild_embed_only_yields_documents_without_chunks.yaml create mode 100644 tests/cassettes/test_rebuild/test_rebuild_full_flushes_in_batches.yaml create mode 100644 tests/cassettes/test_rebuild/test_rebuild_full_flushes_pending_before_source_rebuild.yaml create mode 100644 tests/cassettes/test_rebuild/test_rebuild_full_skips_document_deleted_mid_rebuild.yaml create mode 100644 tests/cassettes/test_rebuild/test_rebuild_full_warns_when_source_is_missing.yaml create mode 100644 tests/cassettes/test_rebuild/test_rebuild_warns_when_post_rebuild_vacuum_fails.yaml create mode 100644 tests/cassettes/test_rebuild/test_rechunk_raises_when_docling_blob_is_missing.yaml diff --git a/tests/cassettes/test_rebuild/test_rebuild_descriptions_flushes_in_batches.yaml b/tests/cassettes/test_rebuild/test_rebuild_descriptions_flushes_in_batches.yaml new file mode 100644 index 00000000..6a87eb7c --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_descriptions_flushes_in_batches.yaml @@ -0,0 +1,86 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '105' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - |- + Hello world + A red square (mocked). + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 11 + total_tokens: 11 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '105' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - |- + Hello world + A red square (mocked). + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 11 + total_tokens: 11 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rebuild_embed_only_flushes_in_batches.yaml b/tests/cassettes/test_rebuild/test_rebuild_embed_only_flushes_in_batches.yaml new file mode 100644 index 00000000..2cdf65e7 --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_embed_only_flushes_in_batches.yaml @@ -0,0 +1,242 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '92' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - embed only batch doc 0 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 7 + total_tokens: 7 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '92' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - embed only batch doc 1 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 7 + total_tokens: 7 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '92' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - embed only batch doc 2 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 7 + total_tokens: 7 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '92' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - embed only batch doc 0 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 7 + total_tokens: 7 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '92' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - embed only batch doc 1 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 7 + total_tokens: 7 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '92' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - embed only batch doc 2 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 7 + total_tokens: 7 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rebuild_embed_only_recovers_picture_bytes[recoverable].yaml b/tests/cassettes/test_rebuild/test_rebuild_embed_only_recovers_picture_bytes[recoverable].yaml new file mode 100644 index 00000000..d358e284 --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_embed_only_recovers_picture_bytes[recoverable].yaml @@ -0,0 +1,42 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '87' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - Surrounding prose + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 5 + total_tokens: 5 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rebuild_embed_only_recovers_picture_bytes[wiped].yaml b/tests/cassettes/test_rebuild/test_rebuild_embed_only_recovers_picture_bytes[wiped].yaml new file mode 100644 index 00000000..a2205581 --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_embed_only_recovers_picture_bytes[wiped].yaml @@ -0,0 +1,46 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '104' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - Figure caption + - Surrounding prose + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + - embedding: 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 + index: 1 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 8 + total_tokens: 8 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rebuild_embed_only_yields_documents_without_chunks.yaml b/tests/cassettes/test_rebuild/test_rebuild_embed_only_yields_documents_without_chunks.yaml new file mode 100644 index 00000000..6d49f289 --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_embed_only_yields_documents_without_chunks.yaml @@ -0,0 +1,42 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '95' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - doc that loses its chunks + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: fjeduffEGbzRqas8J38SvSJo5LpVF9U8X7MGPYX48rxmUJU88HMAvEL/jr2qNUA9C5G/O7amH7zF9Z28vt0PvKdqCjxQeek8MTOtvKw797kqVca8E/nrPFUYFz0oBZ283rcCvUzaVzyx2b+825cZvQCZJz2Bk4A83rlZvRT2dL0ojqw8oOPyutJRrjsKLwy8Iy0Ou6xniLtHHOY7rJhhPPvosjwgS9u5wtfIudOyzrrNT3K7HIntO0p5dDw8e329/eLJvMCPurwTaT08rUdEPHqtHTyjRY68KSFpvbwkWLwq2TU9lvc2u9D7hbxHmLe8CXSNOQnDkLx2f5E7IwInvHipy7o6rau8fiBCO9CjyLzKfhM8+Rw2vKp6kzyDsbG8zBRrvMu0hTxy3Ic7j3cJvY1egLsFHMw8pGL0PJT4vjyHlvw7Jcy1O9w6mbsoITk8o7O3OxV4Cr2/56Q7+OZXPG+Vz7uGR1076RAlPEDqprtBuiI8cnQDPX//GzsN7aI5e2oJvODqgbzqsoS868twPNga9bo9eFo8wLHnPNuQ17tDjZA8PoXkvFGUF7zV8u27Y6WlOy0ACDwA3Pi71m+Bu8fisLwRq9s6xXyovCG6pzt3WAI88gzCOhROnTvUM2k8EKkrvGXTNzxdnSM767OkO7+lGDzLP8q8uv9qu3++U7zWzLY8TogIPUE/FbzUm9W7h77su/8Z9rufl6+8UAqSPD+E8bs/6NC7cjwFuwwpjDuk7yK8VD77u7RKZzxVO8q8F8IjvECd47rNho+8T/09u6izoDwUs/M6KTmoPHd8nDzCinI7Qz2jPIfVi7yWPdU8X43iuqCmlzz9pD88k11UO+MUCTxAX4Q8PTAgPL+DUz2ozpA8gBSwOohEgrxNvB88wlwBvH7Y3btfFf27/tz8uhr2KzwK2ou7ch1LvAvprbuKaAe9DW6ku7nxDbzxZmk9OiPEu3uRzDxJE9s8ljx6vOZujDzKRVi621HJu/YWkDurw+A7Rp+ePEEfoLtQVDi8NhwiuuPTzbvBYTm89aHdu2JBjbxlwts87T/evCNp0jpFz6A70uUGPHSD9DxLqpO741Dnu6TYnrwOMey70VclvDPo6Tu3xx68ESkMPKICjbz4cGm8kXjYvK2cXjzYPwg89oKzvNofvLtDkpQ8TuiwPKyjRbxwwLy7Y26dvLjLcDwqDri8/vaTu0rPFLzW7YI7tAAOPEsiF7sHDTM853LsO/SYXrxYFj684p05u+fD8Lm+tCU9g8wSuue0oDytIES9HyeSPNx0FLwy1jg8yToIPNBM4DoReo+82P6xt/6ToTvxbvQ72lwmvAM9wrzSb5c7iokqvE2yirxFbRG9r0hCu7aBzLrcKDs922uLO1OxKbxuUJM7aVzPvEf2Krz4EGe8yzc5vJkhGb3fHZ67RYVNvC48u7tHUOS757xuPHCyCTuP9Ns7Aeqzu4eZaTwvMHa87sLnO9jiEDw1DWK7q9ZYPPu7wbw8Gq88qJ1DPBOvWjwzK548MIWrPN5QeztdsAA80rjuu7mlv7vXeRU9ibsFvRI+ljveiKG8UvK4vI2MLr3b9Z47rIILO61lNLy1uc68aFiiu4xVTbz2LjG8yhQ6O4gN2DxaBqw7K9YhPPJwXzxQcVe6qx+kPL2Vt7oK3mu8dUYNuRrdoLxhSou7Alg/vR+Rkby/hxW8Xsy8vBm177szmLW7Y0USvHRAx7z9dq+7V5ITPVS9pTuya+083rSnPCkNmzscfR49RLk6vWx7rDw8aS+9AL8VuzuThbzKtte79iskPHcHujzLXo28gdZGPL5MYLynxQu84Ab4PMJ4Kj0p3g29yPwnvKdFGT1y+hc6178UveekyTt70Bi9StdrvF96tLzsXw28TH+5Oz2HJj0tAt28zoaaPPxiBD0wAQE9SoWVPEElCb2B7EI6l0XXO2X8Jr3MIUq85BsbvCBjHD22ftA8w4QQvSm25jyimKy6AV4RPbZCN7rkwBg9heCUO3BP8butfz28axk5vNI0uDuZpPM7pu7YvA0AZjp2txs9SJyIvBjY7zsB5968VsI8PfUHLruDRqS7jyajOyd7N710anc7dUI3vFNM8rxYdig8dhc/PDERcTz/64O8NNgcuxPYrDyOBs+68dW+vIvstrwIARy8c0JBvBEFiLyGdvE8sDeAPCcoX7xJjDC9U3c/PUilAjyWfAS9eI80vW5Jqzy1cxU9JDzTvJcLLb3Y5DA7bJ8TPL7I9LyuAz+89/y3OyWbnjzJiMe8zHDju/3MNjzt+xm9n8gWPF1dfLsRyzY93eelPE7rJz2T11y8wawdPG7n1rtYszG8+aHEvL/tIr3ijg45pJHiuqNU0TycNv88B3aGvY+jKrw/1ze8G3UDPILoAL02fe68+/60vC/VFLzbEA885rmZvG3MQzo+hjO8oukDPD9YJrvzS5W8Eyvuuv3Jpr0AcBQ8uv31O2LYMrxIEkc8QayFPPk7T7yzY8m7ELwGPIQXszp7OYW8+w4BvBk2/Lt0OJY7FY0VPPDoIDzUXn080+18O1TFnLucuog8piu0uiHcAbvNjMI8pvGoPQ0ogzuBwhI9ZmjXPM5r8DvJjQs8HK+FvMUWsjybcBW7XjIavBl5Wry7ksK8McePPI+My7tVzx+97RvAOwZUIbx+XH27RctDO0c4F71gaze6dNq8ukMgFbuXF+M7T3fbu7a5RbzKGmg86qcePRdgPTsShiC8+hXwvJCUSzw3RCG8vUbhvNxNOrwGh9a76WCmPFK8Sr3YAWE9g4xuPL/yAb31IzE9l7XHO2KsszyVUe07O7oXPUDopzytRV67/EOCPAMsCz3zufq8WdlyvCRz1rtCVcS7wIWnPHBBFD3oCUk8+ZWCvG1t0rtXtIM7hBqGvMIXL7wRB6I78BGqvEoRgrz3g1u9fIuEu1HAkjxcHhm8GkjJuieqFDutPi87AmX4PAULgDxMCZg8mgZXvCesoLw5IvM72yUdPM3T9zwsiBQ9pbvrPPqyj7sTwi28eQcePHSq5jj4Km47JBl7PEWSHLuBcT48G6uYvMTBHLy/BCC7vJ/MvKrJHT0Ia1+6bkxMPDe/LTpbThq8/qJlvB838zw1E9A6e6jivFQ8jzxa8PS7VvlzPE2jXjqsFka9j0gavOPrLLv0zy68FNYDvNWDN7zFW6u8K5NbvYIjgbyc/2E8XzK3Or7cO7yRfji9kU7XvNtGPLzYMsk8nD0/PdjPszyuvB29piv6PKWWTbxy2IS77cVSugFTAD0lnTc8KfEDvXBqQbxxsie9F1w1u31RBjx7nsa8ZZrcvKAbdjzsZm083vCrPFKhVLxMMlK9xvcvvHVFRLzhAGu8a+QBvR4xkrscM948cBPpu/I5QjxULeS8sSERvRX2oTwR5J88Pp88vMqR7zw5IAy8V9ecPIi8pbvifiE99unZvF48Nb3Mg4S7V7mMu4J+RTxO1eS8E1OfPK26D7x+ASi8fFgOvRYDCr1XzAM9bnGsvPmjiDx0aaG8qZRUO7rdu7w6wbE8WmDZPBaFgLymJ3g89lrCuxPALLuizxM8Y/6YOpUotrv7Dvk8dSxgO/eaATwpdDM9fFR3vYjQcjwUIgo8JiSrO2T+FTu5Kjw8VTmPPFT6Cz3mcAQ93NknvMCNmTxE1yc8PoWPO3NuuzzSMPc8RYzaPF89I7ybbyM7YkspPEB8zjxEQbs8yV7uOxz67jstVHy8F9LFu9afmbwYdw47YLRkOxbQkrzr3uW7/5sDPGytF7xyBay7CbGXOZAG/Dwj74Q8Ws8DvQeltLs3ENW8tiEgOxEQNDwiK1e9XBRKOjWBpztJxO+7pUfmvL+WxrsAc5q8mbrtPGqkgDqbC7E8jKBQPaf4ibxRDL28sFwaPf/XiDwmOcc8FUujuwPY1TxnGg+85BpKPAR79bxx9li8bS6Pu6Nc07s1kfo78mxqPPJMAz05W028mVA2u2cWNTxE+Ee9Cartu1m4xDy9Xea8lMLXPLCnhjnqkbU85WWbuudcr7x709g7hecRPfq5QD0ac5y4SVQbu5x1S7wZOEa8o0TsPLq8vrzm2qi8Zu+2uXsQBr2KSIS8PTfXPPvbAT1A9Ca9NqafPLoU/TtTh/i6NzqgPMhlsLuwb4w8gEqjuwQSoLwOcYk8CvuOPMGyWDz2dPM8uyLUuoSmBjtY4zc8K04cvGWpsLt2dzA87f0rvVjZeTov/o670kZPvFcoaTwFTFe8EcnHuh9SrLpyXsg89wWDvJ5kqTzfmdS8HdySO0M8BD2GJqI8mMxZPCoqzLv6FkA9wmQnPO11hrvTgJE8W7XNu/a7A71LyNI8sGWVPGtajbzsVTe8VMIePRFVS7wAAS27Hg6PO/0toTwfokQ8ucJUPFshcbvBJc48Mx+hPJFhVzzz0zy93RCYPOWeEz1XV/88BMmhPBNtUjzKgCU8TX2IPI6EPrw//ta6XmvkvGc9Y7xjfXU6tlFjOM4ujLt3AvM8TkwbvLzJvbyPIDE8S8lDux+4ozsO8o283GshPMvBdDxAumw9cU3qPBkS3zx2DJk8ssQBPaB/TTwtS8G8UlQLPcpGmLom0808PO7Au9MsnrxOSY28IorbPDWDE7s9+iS8cnzJOygfJDzMrUe9eoWrPAo6Ojx36pY8BBoNPPsq6jocfgY8okbYu5LOaDzIAHi8iSnvvCsHojzcUN87XUuyPGO2TLx63768Tr8YO1YEFbwVoJs85PZbPVyhdjvxfDU6vRQYPOSOCbwJjyI8QS6YPHEjOzsoF7+8tCBzO2o/obtR7O28FHtCuxuZAT0+wmu8gfRlOVF3GTyP4su5cAxhONeWGTyLtRI86+Q9vBp507x8m/Y7R7O+u8KvjTxRyzG9CgLzvPilHL0p64I72dEzPFZa2rx8kOA8iHXePDCIMb3U7bi8rbUoPAzPXTwxPAk88032vGB+8bx6OZM8/ZwZvTdFlDwt5zS8SMxKPAFXKbwEzMM6iKgCPBf32jxG5So9joWhPHkNAL3flxC8qfPCOuTcnDxZxoG7rywUvCh5jzxWyC+8ZZCTPEu09DzmtVa8TeSDvHkRGbwW7Lg7HkXJO7X55LvzLCK8dL4yPH8onLzpk++8i4yRvPiTuLwIaK+4OTYVPf5QRDxXnS47csLnO45bxrzI6ec5RYvyu0R3yDr6E/U8MZwqPJwW4zyr4ci8nZWrvOCeljzzhEo95qGXPGrDHbweeIu7j/FHPJXXSbvcU2u7wnuEO5+vlbzgwZs8K6+WvBDEUzyLhsS7v/AUvIOCUTytvyE8C0CAvB/Y1Ty6hwo9dp3FuhiAkTt74lk8hHJoPC6+hLok1to87y03PcrixztDO9S81TguOxtW7jxrKJs5WRvmPBEWO7zwVlK8CwVFuTmmNbvaqiY8npTxvIgAEDu2AFE8H78JPdvlbbsnwzw875eTuznz3rvCd9i52G9qvKi/jDzpl6e8O+xJPR7hGz2G/IC8X+hMPKvf/zwooK85gkP2vFVg+LvQh+c81dHbvMFqgLnHRBk9zsWvvJhS2Dyk1hy9GHk8uiR1Wrwdrna7mLaauwn9kjyrmL28UXPguq7FoLwI4VO7m5ZGvNcHzDvZ1AU84IBPu1vQ8bzwLic78urCOxYVvzs7y2I8yMl6PGqisTyYgfk65uG5u4t0Ub3PXbe7S9jWPOreMrx8HSE8DjcrvCtFMzyRGPS8FOr+PAMgLjzMlvs7RRzEO5Wun7xr7aq8wtFDu7AiB70piL27/fdDvSet8LySoAq8XXYiu1NMczw4n6K8kSbZPJJr0TrAxRy9islUPJcyHDwO9h68hecIPCkfk7wborY7+/6GufMo2TtCkxW7hFToO19nzDyRPeW7t2O3uw6FT7xlsxc8VYwNvX+d47zgY/q5RoVMPJ+Z1Dv8iqQ81Rgrvcy83DwRtK88mtqnO1vMcTwiazk7mG7rvGLDZLwEV2K7qk8Cvc6UfLy+CqQ8s/s1vJzK8jvxzoY74TMhPf8yuTzu2Iu8QERZvMvnr7rvKWa8EOI9vKaJcTwkB5W8iFivvFGZJT0Zrx+7xU1VPIwJITzz3YM8OeezvOac3DkUZ+g750pOu2P6lDx/HgU9bYeavDpbZbtN9Xg7Pm1dPBcZ1bsPF5M8tFc7vOGTRzwVRSw8ttyauLBF4zz+rqo8uJc4PN/kYjzshSc7oXDmu/Zpjrwddt87UyuvPE+1FzwZkvU6jOspPA/uy7tOAfi7aioJvFXKIL29zmg8w66+O9eVkDy9d448WSMoPYYlZrpOCcc8L0K3vGQnpTyBvzk7+f5gPPS1JLzQ64u7AkBUOhDtnTxMWvy6fk5DuTtI0rtUtw49LcePPDp7PjxwkFu81ZgcPNhVeTxuAj487lbBvEslWzyit8a7Wn7Muxg92LyocI08ud7pvJRSdDys4VC5hNisvGV32TzZrys8wb4WPcgX9rug/PC8s2Tsul2J9TsybZu8EQeJPFcTnDtewo88aMKPPKh7XTxyovK8FhOZvMP0ATk6kE+8kBOeuxE47Lz1CSM8Cu6ZPMunmzzUzxu8UGyKO6m/2ruBCVs8ejy1PKiNujnXB5Y6g5KPvKa1Er2ke0Q8ua+7PGYbRTz6G7+7h54PPPxtsrrCXxY9g6aDuvL1n7xhy3W8krwqO8oL/LxFmiu9tCSDPJKm/bxbbt28UXSFvPNZKDo7hhQ9ufODu2axmjyIJx09ieIyvQ3uV7s2hOi8BAFXOxQgAD2wVZe8MF/lOy86jLsao4w87wfnvLUI5TtOJw09XmM7uqpKPD2DOIy8fylrvNTqjLxSkQO8wcDVu/bsp7pKX7k7c03BPOlExzw2GJi8Ua1kutqAxrzgqre88f+PPFz0+rzxTC69Am1FOxUbujyVThy9o6J/PKp/7DvFWwW9HJefuwht07yvn287dC9gvO50rbxqSs+7NkFbPLHpRLxUiB27Ir8nvaSDGj06hHY8F1CUvAYPbLzL/iE8TA0xvMYWDrvHPyE9zdBaPH7ExbuplNC8L+PFvCCeKTyrwaY6UDnlvPMgDLuYXA+9K19KO1sVHTyzp4A8GimjOqEckLzek/o6ny7GPEPb37wmuUK7fFGGvOGoSjyizmm8ZR0AvAWkELuRyi08q6T3PLZE0TvwbNy8mhMYvfuKMbwr+MS5raBHPE+4KrwutEW9hnvAOt8IgTw5vsc7Z5qdu80/nrvRngi8uZsTO82r/TuERHY8omPvvJZrsDu7Pdk6/NmVPOe49Dx1k3i86LfuvIl0pzvAWHs8ytp1uhK0qTkL+As9PDsMvP7pn7uMKv+73G/0PP0WP7ziWjE8F40IPYvpFDsFRCK8NfwPu33Erzs5eAi9Nj1euyRAp7vYX4M8WNJovBnirzzIp4Y7GvKIvM5p6Ts/iA08iwWHOSM5FbzgjsW8xogMvbIvFD1fq2I8UvXZvDoyyjyYbQG8MuiauyuTwjppoDQ8X4AGPAtwVb2m1Qy9CjapO4WAZL0K3VY8G1XQvJmnb7zsiEO8HcWRPI+TEz1epRW91b/PuznJtrylS5w5iz9IPDl+Gb1knAu7Mvs8vEIsQj1VfMO8GSF7POSPqzwLJs480Ys6vJMlJz2qfqe8VFaIvMkVJDz74cq7MxgpvEHhsDsEbRy8uqYePJN2QTv4hq67P8wEO18EgDx/JWM8DG7BvKBKH7wyiSI9q9nmO/ShEbxJapm8KZQeu0yFobxOTIM8yz4Ct9erT7zQwFk6G/FSu5t97zrlyI46vbvSPDwhorvdEji8o/VdPMWr3jtgjjA8veSlO7XGi7zMiIk8+gkgPSTZtby9fJS7A7/gu7doCjrE6EO9PG02PC59HzxTEKE5SvoxPCd3+TybEuk8OFf9OfzLrrwX6yc8J2/TvLvJFb2gHoo8S0RrPKwjGDxZHwS9ZXUIu8Qjpru1yEw7E0fwPPwHmDzJe8o8d/2zOxD8dDwrV7s695vHPAjKFjykjSc6DnAUPM+OxzsGaTy9m4BtvInuDDsOori6buu1PKWGmDzHw8C7p6aXPBqkobzHytu7oo2dvJIp1TxysY08vtGePFxy9Dyh0jO9mGGlO6optTyDccM8Gov5u41xAbvN2Aa9fcFqvGdm9Lt8AtY7XO4fPAuiarweNDM92YEJPWtFybyGuzw8hcBEPH+b+Lu7R8M8ChX0u6uuurwgfi89EqNjPFJYDLyffjU8Z01LPJ5sXTyGizQ83WBsPNIy4DvY2pI8ELzZvHeq3DuSsFi8nR2AvBPgkDwBzvq8qEh/u1c0ljzWLDc8InlDOKOj+rmNSqs8Qo29OzApuLrKGKO7iMC2OlTNqTwP4R29PeH1uzTinDwbi5G8BiUovMJggDyKqe28f1o/PJKduLxhXnk7oFvQPKAn/jw7yLw8LZXqPHykxbzJqLQ8+mOQO14B1jtWTB48qcrsujMZUjx2rvY4ESsyvPW+PzwaaRs8Cm5YPNOPLrtQld68xpUPvefW1zsmroA8eXmTPJljujrE9ws8mN9DvHt65btpu/E8hsvNPFWvpDm1vae8CYucOYOpbzvLIx+977mPPL6xsLsM2xC7C5LDvC9lyTxjDqO6yrYOPN+wlLzJD428HopfOw0GaLopUEm83bG5PKihNTyJr008j+6EPGF1aby3eHa7RaUCvR9inzwDtqg8MwTBvB0aBbymjZQ7j1l2vCC/Mz2DIbc85D7OuduYyrwbkl26Lejwu1KakrxcPM08Y12su25X3DswR1c8/06DvKuYGDyV0Qu9cVbhvBgDdbw1C3O7VWYNPF8FNDxMl9Y7wIk7PcqR5Du8KgW7M6kRPPHN6LsPXyy7bslaO1QuCLytdKS7T+/zPJIheTyG+w47drszPA82rDzPwE67XlSHPIG9ZTzOEeK7rMSBvDKBsjzCuW28MAUUvMmR1jx0ARE9V26rumZZ+buKYY+73/3xPHwRBb37WMq8W694PBM4LLxOdIc7UporPcZk/joL9pu8hUOmPD3hBTzM/iK8nB20vDmDgLvSI827B8aiu2ziZTyDhJc8Y8y+PMw2tzz4Drq7HV1QvNQhzLxKW8W8YWwXPOegtzyBUci7CUwlPIZptLro2sq8pvyAOgUuS723hRy9nQuePLmsBLyD8EG9zKEJvRYQsjzFlqk8OJHYvLSJijtPLwm7FhdRPJ+XzTwFDSQ9Bw2OO6pykLx5D108PNoiPFw7vLvYiIU8WVGJu22p3DzEJuC8ARckPGNdvTyRHs27P9zAOqFVYDuyhwC9M/eLOhyN4Lueapu5wbktPIxXZbtNV8e857a/PJ8pPTp47oO7VbHDvPuPnDxg9EQ80tlIuvGhEr33p9I8LO39uUVINbxsXrS8SoajPGMsqDwkMM874TrtuwOPUjvdxP6748CTPD9AEb32mBQ8WGSSu2VlvbzZxbm8VyZkPBIiurpO3kO6tAEovCCO27tVzIQ8A1ggPXfgsTys+r08g4QgvDtOUD0OZwA9MYjHOnxOL7wN8bO8adekvN/dmzzsgIU75GPEPKyPrrxTSii8pBWVPBdW7Du95Ow7Xa6hvBSPNrtvFd28b74NutO0+jw36Ii8ZnJ3O0EdaLw6P7M7oklpuyGJJbwMsQQ8L8ctPKw9ozx4MBg9scTxO3oJy7vm4kC7bAooupiZNDwnhpg8TO4+PI6+czwHoB88/x36O8O8lTzzR4E8kbgqPHUzersGJck7ODbCvI8lIb1tJZk7uuDeu945w7zP3f880i2ZPJ3ZubsLqFI8c+PkvGd3ojzz60C9niy9vCmiRjw0/1y8mSIrPbXd8byj9vg8wxFeO7j/Fz08Ai88gDQIvO1OeDzpn+g5AI6PuU2Ujzw++b26aKYIvT+agTyRsOE8mypkvUgFBjvACAE9NCGhuxsWKrtT4g079PHMPCxkBbvFEAo8I5YHvdPsF73WOBM9n5p2vHX/4DxshEC8LbGSPKjmmzydMg+8lTqkvOhLjzwrXKy8B60bPBStD7ykzNy8LEWVO1gTUTyuVjI6oYLrPO15qDxrIfQ6Vc2TPKz5bzzYiV26zIbtPCJzhLyQ1xs6RNkmPKxdNTxgl668RNWMvHBosDw8h3i7JF6CPAiQSzqnmeQ8hpZOPDHMsTxgLCy8j33fPOd7B7xL95e85L8RPMbNXzxeyqs7QTrgum7UYLykMpW86FXLvCKWhLwOW7Y8kUo2usEPdjwCCxi8GpxuO83uwDxdWY286doKPanEoby4bC484MALuxJJzTxxvlI8+C7SuU3zrTst4Qq8Q1oDPYgxbjxq06c8vug1vF9Ys7tSHZw6yxnuPH94Ab1eIeo5Jx/aPI2nTTxu+tq7nicNPM+8+TzBRmg6HIScPHW6Rrw4SBC8NZ+eO2y/S7n6OW68BX6+vAME0rsYUsm7UUXGvDf2A71kXLu8hmg7O9XOrryNl6S7uFJ7u6oNuLzmXJu8EGAjPKDS1LsL5Ji8L+ZwvTzmNrwMn5u8+iTWu9pQtDxB8CG9Za80PPox/by1fSu8CawbvA8VXDwPnVk8BAXLPDmHpjulZrm8fIGLvPvPLb3otF+9Ak2ZOwBJu7pA4dI8KzPEPIE7hbw7IKg7fPzxPFlMbbw2jI48605VO29Ly7xJmpW7AyYtvbXtorsgP1M97aZ2PNNKcjwOvkM9DrcjPGnc8LojdzC8Tgh2Ojh6aj1XhUW7p0osvbOPWrwN+YW8a8QsPHBHm7zrDBa9hRyNvOL4T7ysXI48+HkOvS5eFr0ysbY8xBOePDUyI7zbxFy82OfIvEJ3NbyqVYI7pRjTPPplkrsN/nG8hW/XvDRpDj1QtW+8AKwvvYQTqTvLCyC7g9FbPCVnJ73RXJk8DIx0vKKj4jwLehC90pKOvEUdyDyzQrW7U2V4ucoPMDyFRTW8WOYHPPZYgzqNqsC8EDAOPPCzt7wCm707N4HdO1IFabxi9q47L6rNO9VvJjvW4S+93GW9Ox96Aj09Wt47dgOMPPVPdjwS3cy8l1vGPALv0jsOoSu91TUmPI13E7uJ5VK6mdDNvBLZhDxOxms736+xvB6ODTzlHPy7VD40PZSQtjoEp8O50KlbPIxBZzsTKg86HSmiPLDnObygiTC8St8fvCUXLDwn9m67un98vChUwDze8IQ888+buwiZ2bz84BI8fQdoPDKwVzsh+Im7N7RBPLDrUD1nj8s8MMYJuUVoeryYHOG6NtcOvHkKP7yI7ZI8j4UxvCn6yDtTyFO8VmKrPKqF57tM8ms7KRvPu5L0qrz0dlm7cnu4urNa2zyv3SW8iqNsvGF40jrdH6K8P5wIPSWfTzyJJ+k86Q0JvNEz3LugNPA7WNrSOtlc6zsGPoO6bNydPBatJrsFjE08LH0GvdShDr2ye8W8nMOpvGoETLzE0va8PzkOOzbtkru42AS8aPhMPMw7QrySpFA7afs+PNveLby//xk8XusTPV0ErDxq/hI8Qaa3O+WY/zv9MZ67Q6ZNPJg3Er2FeWK84ymrvIlMB71eoXg8DNfoPE+tdrzc3Vm8PEIHPNDfuLw+77e5tQ4SOyrLz7sMy3685vmqvJ1e5LxwIlg7+vyiuf+cTjs23ho8hFnIOytUmjyU1EG7QQIBvZOLHr07gWK80dEOvGv+BTv/Kv681M3zuppo+rxmWoe7fuGvPBbKmrxfd707UkDWu4YdBDoTUbc8yrx1PJdAwrzIoEk8tnjLvFq1ybuf+IK50dGrPN5cTLzZiw+90Y+zO1Vh2Lvyb848s5BfO3uGAz3cXgA8Q+U9PA/qxzqXxBG9v+MNPOnnJDzL0is8i8eFuwb1hLwz/3w8W0lCu4YkizzNwr08K1cvvIM9LLw8PMA8AH6SPPG4krzIERc9keuHvBrHRDx0IDC7/woXvJ48DTyBfgQ8R3zpPBl28byL9dm6Yz8HPS0HybxhxG+7N+3RPMBcm7yJd2K5Eh7YPL77CD0AGDa6aCuTPIJ8Ir3drV46YykMOwIZFr1pN7c7Ralbu9TJUrwNiUa8LfQsvA98Hb3yj7A7ZcWpu63kRry2aI+8exHCvL5+8LrGO1a7mpYoO35HiToN7Qm8BXXQO17d+jzzmD8774MJOhRxezxZqI68v7qivAI7tjzVFUW5MdUhPCEKAbsCfoO7BCmYug83BTxQAaq8zAW9vGBKkbxdi848pwi1PAYeSrxYoUk83o/xO65My7yfl+q8kMGGvMv4Cb1plKS8ug4uPKI7CL131l09DYfvuesw7zshNEu8wJg/PHBMcLwuYf26ORjdvN0gazxcQb07t9Zvu+DIszxtXai8Zqp8vGCl6zw7ajO8+Ab8Ou75mrzaRzw8Ma7zu5sN1LvtU5E78k5RvEraC7y7qNG8dBkwvWpBzDyX0y+8kH1NPJh6EDyR8q48TnZ2vKMaHjwYdLO7p0jIu9wXijz1syc9yz3nOz7teTudsCa8bCcZvQ3SMLsg82E80uwYPDVYwjwQ/Ag8Pq3yvNsACD2onSK6rbA2PHaFOrwtyv88hcsNuxyCpbyyqJ68p3JcvBV3cbkkSMu8Hyx2u2xTxLx/Cga9rQ1Tu6ZD2rxS5/27kV/7vMSD+DwugNG8I7CmvNQTCT2WmsO8UTFxvLZwkTy4PzY85Vi4u/VFWrvaGJ08UpdxPGJycrzGLgW9Fmd+PB7zuTuLGh28IBZtPHId0jqZA5687KYwPAg6bLzSiPE8t/nLvIoHhzyW99c8IppJPIQs7TuN41O9TZrKuyGJLjuvFsG7cP8svWTw7jsdayc9MvRvPI+50LrN07g8yN0QPZk/yDyzkdc8L8y/vMj3UrzILZK8gZ5GPbpNKTwv7Vs8s4gLuoKFHbzw3DW8HT3IvJDspTsmsao8cd1LvN2/lLoUSfA8M/qLO/s1lDtjv5K6R7KQO8S1sTxa4tK8mIicvKkb27zLDOK7WyFRO/RlVbk8+I48EXL1vPLHO7312p+8RgxjvG38+bt5t3u8XPRXuWVq6zsrZlE8ZRxpvbeYxjzTfK28iJthPBznTDxaw9K7UYS9OdxOwzyUbYu7cFAtvPCxzTxsTAI9N9CxPH988LtAmrY8wIo4O3zxWjxa0y28+HvMuxQUerzOcIc6nSaePJ3Furws6so7Je8TPQusYjzN7pI6Zii7PDEURrsvjKS6J665vEilq7zMqsQ8vsA9PMn4kTxXi1C8HlcTvZNuBzw1MJ08TNUGvXs22jspYdO73HDFu4t8EDy2uQA8ye9xO1pnDj1WMxs8RLCWPKy3rjv3XXg7XJxWvPhfqLzkTsO8AQ4TvDRJVTxszL+77dbRPCw6K7xYkhk9eyifPM/vSzzlSIE7B9HpvOqR5rzljqk7gQHzuo01CzzqqhQ8mE2DPIJjljysCtm84K6nvFb2izzweTM7Vr1+PPLvqzxXKdW7UdLWu/V9jjwzMfm6OBPpO7zVezuv7I076SzgvFDAnbyeL6U8d47pvJAmBzzsyvo7f3BDPGpg0Dsze5S6KrVxPMIFwLpf26Q8YszEu37FhbtDqEw4Xo1VvHps4LsHNQK9UsXavE10bjyMp386J/hxuyy3Ab0fN6s8r7cNPHQAlTsagQG8aNgYPKs3fzw7eDa8nA0bvEEFILwDToE8rAsSvbbIDDw2Y1i81lmbO2om2Dk9hNq8sKvYu8k7zbtStvc7tEI7vA== + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 6 + total_tokens: 6 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rebuild_full_flushes_in_batches.yaml b/tests/cassettes/test_rebuild/test_rebuild_full_flushes_in_batches.yaml new file mode 100644 index 00000000..65b288e0 --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_full_flushes_in_batches.yaml @@ -0,0 +1,242 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '86' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - full batch doc 0 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 6 + total_tokens: 6 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '86' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - full batch doc 1 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: qM+nucPYy7xym/e7j6K4PK8EmLrdy4c9iXNAPW5BITxPknE8v4l+vIBrqrycx+G7JWJ1Om0tLb2GWje8drNPvU/dOzxqzqm8OQCCOyn1kbv8LtW78QYhPYnwNT2nCk68R5TSvMLTQr3AwuW8lct6vae1I7wVqYg8IIFgPDeOKr3gt1U8dz/XvOnzyzrFFqe652ruOYrQRrzNj467hOcgvBHO3TyGgLe88ukQPAIkmTv4CjW6EtS6PDQDBzxxDy69+svCvFhujrwDeog7Rr7zOx/R/bxhM1y8rqfiupeS3LsOnvU8RLr4uv3qIr1Gqvq7a+xxOjj0xrtBq6o8K+Y8vJDsBrxBAne8rDaVvFquXryDdD88az7SuiQx/jxlheM8PLYSO4iAyDo98gY9v2POvKsJurtD+u08I7qHvGg1vzxKsT49ckUSO4QS+jvVOI48Ve7xPKtgWjzbiOi7+uXhOw+jt7xy/eU7SyNcPDlVvbyZDaS7q17zPIubuTr7ozY7Z9IzvGi5p7zswhW836F4PCl6HzvG4/i7GMdfO9ARnLvVTHS8Pw0VvcMst7ysFB+8G6Y+vCCXwLsLIcs65WSKvFSMlLsYj4Y8cdVtvOqyHLyBTBC685UDPR6C2Dz51Uo8NSulu4ZxuTyHEf27YN+NPIyoYbzGppk8lFMzvPxOzbxTj4M7v/zpPK7RYDzLZHy8uoVfPG7tkLxbQAW91GXRO/JDabxNHIm8P3oLuwWLxzv7Kwu8zHqCusrzsjwNNdQ8G7Z9vIXGs7y0VyK8125ROqUdJDzN3AC8xBjvPFV0kjxcGNW7ZzyhO0TNHTzquMc8sAGGvA2x9TxCA0c8tULGPKcNCrzsBqK6m9GtvFsmsjwIAGA8P7NOPFNhJrz7z9g7GtpnO1XahryvTJw7Vj4WvLaUL7xi8Kq8OKkPvSh6fTvIZQe9nynVu+Ec1rtJ3SM9pvkpu6SMAT1fboy8OPIBPD9RljzXVC26Vkc+vDaQvLrBDbM78USFPCCE5LwK7iA8l178O9uKjTyFyGK7cOhbvDE5kbyyH/k8kpOOPK7J1zxKPgU8pwwIu9QHDD3gZ128GnKavNu/g7zHChC81HfFvCMfnTsabBK8TOFkPFClTzwsOtW8xZLqvNp3szwno7I6ShMBvQfxDrwTDq88rITCO9CZejkRqo86ug7kuBzB6jvohwa9lsoePJSSLDvbYIi8noLeu+JAPryZxfm4gqORPBvE5bwxzWe75JMsPMS2vrtApMw8InySPMjzvTx6SV29/rLLPLbto7xjqWq8t4sSO+cquDv1rJG7kM2dO37wrboRvlG8qTOsvMWNSrzoY7q7gE0Zu0Sx0rteNXI8B9pUu3K1ZLz7q9e8TeievFtslLyH9T088CNgPPWjFbxzZPW4Fwdou45LFLxVbD683GYkvAdkPzx9LRI8AwGMPGaBgrt0omw8WKPVOzewHTzyc6W7ZxaJOnA5Azwxhz08EBT9PHCmprw+m3a6JdXuvGkqPTwl8x04G0vLPJPd8jxpBuq7MtRovFQ9GzyH5e889cDovDAZzTzS6LS8Hs8Svf7pIb3igLM8YbCxu2MDprw0qMe8rrndu5l8IjwJB8M8snw4vCpnrbsKNkc7xOIYOr8Gcjs6HY48MQtIPFfQGLyLu2g6bWaTu6zHpbxajr884/3VvMshNLwO0Dy8aeYzvAxDE7zK9JK7X0ZtvXQx7Lz7Ez07f0o7PNk1jrtUbh48khAgPYP+MjxY/VU7jJPovK60DT0IuxO9B31cuytPmzv4XQQ60L/XO19Ouzx/6Hg8kSVYO9HHUzuVVaW7oM68PNF0ZLxxiT+9JZW7uj3Fejt4S3M8Jj8uvQZXrjyA3hQ8WbYXvbv0SLs8KCS733SDPAF+njxNlwy9lAAiO51gVDxrBSY8NgyYOxBRJ72+qwK6mbPvOxESNr2xq9q73xJYvHS3RT0qRda7L9RxvN/h0Tz7dmS8EBfLPNpdhjo8jcy8yzIlPFLv37wH3ZS85sQSvF1JmDw0rqQ8eS69OxV0Uby74Vk82cJuu6nIOjw3uAK7x8cfu26qrjuvSok8SYRCPPH9kruyKUk77hY2PAHAsryMHBM94tS8O58LWTxgTQg9klfWvJc1x7xjJlo8Aqh3uzTY57z1PZ28cVaLvHzllLyw9uc8NimiugAbwjtADNY8Z2pXPKpbijx6nXa8pvE7vfNrcDy0+P48tFDhvO7AUTy5W5A8jqmIvKCdsrwSUlA8Hq6GvEDSsDsPGXQ8isiIPEet8jyQmAK95TedPKV8zbzI8F27agyfPL2tCT2sCN6734OPPIwAPjxSFZ68qjjIu2VgvLzzEaQ84KveO/IIrzyHuyk9PFg9vUX5drr93B27b82DPBp8Bzzs/Fq8Bnb1vFjpHDtCaTY8INqcvEJZNbxTXL87MFLZPMgVnDskeum8jcU0vN6SrL1mn0W8phwduovS8LtmIVY6wURAvLaxbLys4BO7vQ/XPJVU0TxTfMy8gAuCvFGMK7uzck68hacyPKipsjnzTV885xkqvI9tmbvEDR8813tOPdGykztLfM082eyxPDitz7u47Bk9qBoZPPtvPrxTUvY8OqzEvAP2UzywCT27QsEHvPF7prtDFHm8JcUWOxis9DvLKAW9gN2RPLPJAb07yLK8EQjbPLdYCbydHN27WRF7vG/av7vxt5m803uwvBao7LzcQ1Q7P2FQPcahxbrvqly8Qks5vX3JcjxuwMG8TdncuxDiRrxa62q86AjmO2dqzLxLQ6A8QKwSvB06gLyNCP07DCeEPGw0KDwVr2K8FIdLuUpyGLzTX6W7CcbuO1SHALzjkww7vT8bvWYyrzlNhSW7g5jsPBbpbDyfeM88mOS0vCxmi7tKYZk85CdbvG22wrs72BK8EehqvA6sb7zjMgm9zxYrPMtL5jxIvFa8an36PJ3A7rzdHgG71W9BPe8v6Lzqbq48ib4IvCW8PjyQd/M6q84ZPHpK77c63qU8JhIIPB5ZOrxVHtM7oHDCu4n+ijtQqhO88iK3vNiIw7u3Uu+6Cpk/PJdG8rvUhXa7VIX/OwZIqDvwM4y8vrGMvBGPxDwfegs8LyKau2DmebtoYnc6xI83vCeSXTx7g0s730aNPPHIcztMBCC97YviutrgFDwtjSg7S7V4uk4OuLw7Gri6zYsXveM5C7wOa4+8IUIWPBWdhbyqjfW7ccsHvIpmcbwCTOE6BCySPKroWryZGE88t39gPLrbAbwyL5g8TBAcvRhnQDwwSOg81EwlvY7hgTunmfa7eEWGvBGeNbyx7L+8Lya9usOBEL3ngyU8IgYFvUjHFr0+R1+9l4UuvIjHjLyx3ua7KWwOvU9LVzxBZSA9b2pevEZdLT1kzAK9tMtTvYqHsjzWjAk828kEO7sfMD1XFXw8PXDkPNVaDjuFd4U9O998u6Sjlb16rOG8Pa9SPK5EFDwpBAI7CO8wvDXVC7zIboE7M5HyO4g5NzxY5wI9kRLiuwvwLD3Wg/47tLl+vJ/1AbwZ9b07Q9PLPDK9kLwzyj28O49VvOcfGb0ckbY8QDlMvLbzl7wBLgc9MI5/PAibwrzJfOU8nlXEvBSuJDxKz5m8BprQPGXjijwAUV47NPkNPDlrmzxdxzK8mHfZPJ83B71t4Gu8rWAavEOHkDyINQQ7DRIJPCUSm7sZToy7isMAPIkzOTsU5pw8L+QjO9aV17zVdRC9ndF1vN2hC70vnqi6N1MVPFOF5bzHhUu8ZUcRO6O5kjyAIma8qW/GO/QqSDu5Y/+7aXZPvL9KAzweM6K8tBfTOnH6rTxR+Wu9AwdCOwqy+rnCGg68xFMyPQrou7t/K968FiglPTRuibxTKYg8CohyPPP+zrvz4Sa8HuKDPe/LYDy3Yi08ss3NvNPbijxKl4q76C6Gu3WiLLyH0Vk8zBaoPDp4/zvOfEy79IUYvPowODsErzO8XLoKvMwGizp/ePu8qXs4OOR8CjynFOK6z05JPFCnmTxW+CU8qLULvHAdPL1Xg6o8v3RkvDmRqDxYCIQ8JT2POdaEZjupPgC9A5O5vGPUi7vDeG68mvruO0SRODw4szq8zeK+OzbZCT2pkvi86jlmPLwesDyyaSO84oIVPBzbhzyGSvq61Z+FPDVUoDzKFJM82jLTvEEnELywQ9Q8yYbCvCj4Dro8cCo8zNgGvcHMUTtsJW08/A9uvIcwxrwLp4E6uPljvMhlO7sKFAg8kCDDvGxTwLs5nLK7BDoqvf1Czrt2+xi7+5nmvKl+jbsalIw7lgkBPDAimjtw5wI9KVEPPDbObLzi6gQ6TDwLO11BGL2E9g69PdkEvUmiHbzf98y8U5GXPLiup7wHsDa83W/dPOjgGT0HTnC69q3OPOSAmrwuubU8MFO5PKo7TTxABKO8LD23Owy8VTzaRLy722wAPc0qdDznIS48NiipPNAlqbxSymM8nU7hvD1fNzwPPpi8I0i5PG61Gr3Sz0A9oPwgvJfEATxxjIs8arKBvBQ2MjyakyI81+KmPBFNLj23hGU93afpPFd+AD37q+28sX5SPEawtjz8BwO9QlUmPOBzNrp5JhA9GrGku701Ob1/foq7brc0PA9VHjynVrO734UDvZrPL7y1F++8vVQOPXdZtTvu2ww8SRbjO4Pcszxt06s8LcKPu+gOwbiDsdA8qbWFuTOiHj0iBsk8MJ3nPKIMzzzh5Py8yi/iPOa6pbzEBt27pWnwu3nRobvUh7O7ntfeOt+uWbxnKaE8SkVOvMALw7sti6C8JNgevTLptTwLIIW8IngtvKq8ED30/vO7M7Viu0hCCT3stVI88ISWvHRI/Dxtty086WsCPLX6l7zZVIW819vDu9bArDw43gi8i30qPEBksLvlqn889QutvDCDArw41AM9g5LKu3DQQ727+9M8plE2PdY0SjxqxNi8eIOQvMzOQL11Vom72RY3veFpUTm6+Fm6+UZ5vC8dJTuK1zY8691LOtWcXDza6cQ8KgHnOxnOK7yMJ/2800u/O76iszyQy7O8bJFpO2j6Hzt5DK07hVmgvN0xNjxr4gY6WFVgvCXM27zSO2k7tN6BvOskhLzdeHI8i8OWPOPe9zz3qUa8fcQ6vQQwRjsxWwK96h3PPJffWDw9BQK7dAQmPNw0Fr1nxnK8wJJcvLrNLroTUOC8OiMvvLAzi7w2Ghi9FrqBvBzoOrxknT89aX8CPSV5LT3Wttu8Nw8ePEC1bjvKLBs8lN87vNREEL34uCY9LfQXvNW0zjx/EkW8rvBVu+kV/TuGKhQ8WeW2u9Lkszv4bgQ9Y+YTvNfjszz6Ch490zySPJyxs7xkKAQ7/bPhO38Whrz2lrG7wB8YPFYtxzx7i6M8iAPuPC3UArxDJ2K8rcW+vHosbrvkjSi8UtgfvFkLYDvz6OQ7SLtxPZYXK7zWys+44lAtObwAXjxpApi7ikvEPHNeDTykTL28NbaaPCLGRjymCEE8IwQQPFBtzzxaKI+8qJsOvLoM7Tr4idC8nZbpvFolqbnJxSk7Exxku/MELbzmZYe8pmcGPdHDk7yBl9y7oi68PKl2Fj2lOAM968s0u91imrxkaDy8V70KPCyVQzwmLgE64avgPP7+PryFXze8WpYIPZrIILwvorE8RO5sPRv3vDyDjWu7l0R4OnKR5ryt+jC8lGCuOgs92zmoBxg7txadvMS07zs0EoC9WTJAPYGqQby3CH27DhWKPJ0xArzbMR878aDYvBLSHb08Zb+7H+EfvdbLO7uAbsO8n1CfvI33WTwI6e87b4oMPf4C/bszrdy84oACPXKw7DvTefe8dnqAPBdR9ryGR2I8Eel+u4VF0rybJTi8YLiFvMfrTTyr+ZU8soqqu56yXbwTdba7ok7CvGB9xrz20187NJJqO6eB8znLsxw9cd49vFJJXbutOgW81r+juiVRnbx8RUW7EKV7vLxlEDxLIjO8CjHjvPbHyTs/fR09RzscvK/fSjynvV67R/ufu1E1JbvLC4o7GiUPPNECALzYjQ296pCvPMzEQbywB++8p2i5PNLUIz35DNk6iAOhPMIp1Dx3+ym8KkmMvBHYOzzzNl48cM/cNoO2djxBbeA88d2jOfLZFjw/d408n4qYPP7ZuzmzKxM8vbePu/3yNTy5q5u6Xe5NvJpM4TvS6XY8xT0hup88JTylwA0816wSvMLJoTtitYC7tB30vMRpizx5ELs8uFODO9tDC73gJgK9i91JvAl247x3y1Q8M+wkO+jOkrsTwPU7ZcmKPG6LX7zaOIC83M4ru1+r9jvbesS838CCPE3o9ryhLcS7a0UAPIiiajnc7Au9+f0APOP2nDyhKRU98kkIvMP11bpL0RW9hUAquz2A77yNlA871vvNvI0fGL3qa9q8CkiQvGE/2rxxMY87chxevN6ee7y3f3E6sQ6AvJRu8Dz7Mdo7y7I/PRZEtjywbYa8XYOPu6snnjzel8W8GeKDvNX547gS3VW8+yBAPLggN7zqIi68vgubvA+rxTz5txG9DyMCvbWwD705Sn27PkP4PI07gzy1W3G7iTrTPFF1TjvJafs7MBPyPIn9uTx3uLk75q9gu46Ibrx3IJQ6b+hSPQVPAjzrA8M8aVlKPBcJgLtgNXk9OPd7PGRmQLwA8xO6E8OkvOU6Eb1XGwC9aUgwPIQ9Wby4P9i81jsZPE/mzLumnRI9qdO1vE9Dt7voQYc9iqgEvAyy97xL57K88zAuvFPwszz0J/e5u+eQPNe+mbukFdQ6zImwPON4nDso27k8Dfb0ux0aXj1xc+e8UFKZvArxkLw1pgs52m4CvINiITyhllo8UjDAPD/iUbwvfz+7uokau59r0jvT/Aa9W6wFPcU8LLygojq9HjstPFVHRDwY4pm8UdjPPItWC7oJiCE8KNg7PJ9/pLxw4s87UnM+PJX+2Lsf0x286B1YPMAXwzr0N7q79gfNvMuOET0V2dK77qFgOxKU7rzjh888i3EpvbLvT7ySPZE80o/yO1p/ILzkbrO8oq27u8/QTLwO16e8dWRTvIpim7wmZ9m8jgE/PL2pJT1WsR681JG0OvRplrzpEy28kYOYvIM1IjxZc748LwQfO5O8dTy5znW8xbfBPAX+Dj0aVyI7u5NOPWDznbqapbq89ODFulUzmbwzPX+8fbv/O/bo0DuKaiC9cdTGPK5VTbzCHmO8+3jYPPNX6DuFbD68xuyTPIXxlbsKY7s8jxwju7HUlDzxlT88aXU4O3s/7zxU0UG9V+/UOzdUD72dtwi78JSRO0uQlTxodwA9dcQ0vV9mjzy99x89VC5aPc3PDzyeGRq88huYPJDgA7uviyG8x+2IPCjtsLw0M7S8U/+zOmJqY7vEhZ873PqnvEu5jD2jrvw7MOQZvSPZhTvZID88uJwLPQ10CjwpD+e85kPvvNvhbTykQRO8eFruvDyVZjwM4ak8oP+QvFnkyTszTY+7Ie9lugmdKb2DqMQ7pIbeurLJ8bz/WQE9gP6/uyh2xbwv1H+8jAZJvB69MD1odOS8FR/5u7aCrTqkK4q8QIeKu6MFar3YzU47RzwvvGK5Jz0owhS9QkYYvXYXszt5uMQ7+X27uuJUCz2pbqi8zyzSOgNWTLwbROw7ewJQvETKg7zqAHy8IkPZPDtSBTwQF5A8wMLwPNzV3zsJnbm70uQcvNy09byUpgE9vy+hvA8S2bsxCw+8pwYFO4wWlrwB1oY8bxnBvE02Drt0lZ48wD2mPKHfeDwnioM873+JPIvoFrsL/2W87kYJPLXVnbwJrJU8pLvoPHS0qryPqjA8liPhPEd3r7wmVv+8oToOuJLWtbxlS3W94WQhvegj0Tzb23w8mREGu0y0IDxgpwA9862wO0SPDL10EBK82AkWvclsrbwpDeI72cQdPcEEBzz5/2W7g//NO4KhrjqTici7vdAHPB26v7uLaZU7hgGGvPgtDTyL/l+8wQYCPSf0vLu58UC7qeOjOtU+xrqgNt+8o95aPMpPRTx/ZCQ8MfTfOyNgdjvZu5u8dLnFPKRlADsuTvQ7L5iouvJbfTw0xJU6bu0qO8mS6jyh0zC82gjFPLpx2rpFhVk8M0GFOooWArvpFSu8XMeDvFxdMbyj/9u6pSlIO8ockLxP9gE9wDH2u3hnhbvBUoY7cRYsvDMuW7yNvV48TEjuupjwjbzgtWU8h0fDOEDuYTwvKzQ80HuCvA5aobtsbpk882OqvPy4FzujzB89o8savNxUWDwlKbm7aevHuzO/rzxyqcY8ac8SvJ2E3TxZugS88vLmvF3BDj34gp88Uv+1PARXirwoJ7O8meXmOrGjQT3DC+E5axnoO2EOJDxcEUs8c28QO1sW3zz3CFy8Q3OlOtgrsby3N9c8FdOmunLcrTz7cue73vmCPO8nxTpeWgk8OqESPLc/NTysuQU9/74SvKEV9LxA52u69NY/ttfzn7uv0AY8sJnpPFJNsLxQMsG8S8y6vMY1lbyDCmu6YUMZPTH7Q7yipVi8tA6ovGUd6Tu3JAE959AXPb2Ulrw46su8/fCGOxgCmjxwbhu92sp3PCoJqbwCoSu88JS+vPxpULyxTMC7JFoZvL/py7ykvEQ7tORIOrW+jLvozu+7h17rPOFyujxAMos8KV/VPNj9Cbusw0s7HSScvAwp17u82S49h5iBvBNHVzxiLMi7UH5xu46eOj2I5pM7lIAZvYamkTxw51C8dUECvDn+tjzRdsY8a5IDPUFawDpvmSM8OvAWvcnrlzxlyRO9pkP8vCArw7rf4GA7KtJAO4a9nDxMilI6J7BYPNBCqjwz4ck8rxaXOwU6BLwM/ig8r+AdvCUknLuRm1S8uRsRO6d14zofmbi8tXCiPM8Xwjw6qXO8sqHEPEu1CLzvIZu867jcORzbKzxfw5I68hOHOij3Az1FXhc81FgBPajTbTrV+1O8xM0IPbhizLxt2a27tq7eu/k/L71Q5Ey8BEH/PDqVWbzT5QC9+822u4iJGrzHVyK7IKxXPPte9TwiVw49jWTAvM5UJz3LNLi7zyq2PI34Rzwi1O84/4Y+POrvFzxBHjG9xmpGvMblUztPov47BCeLPKthEjvk2mO8jQDgvCkJibw4orm8NtqMO9iTgTx29hG9ZKf9vEjPnTyJwhM9WlWEO6sNVDs5Uyk8N6X1O2XZy7vUpIE8tys7vBE3CLu+aQE8lX2bOVesVjwr65Q81PfmOeD6oDwLe/Q7nRe0u9JVoTyYuw88DYz5O8dXiLwck+s5N0YGvBFag7zWf1O8Oh5xvMPPwbrZPXa85GmjvIdZSbtbdac72wVMvftyUDyTD8Q8XK5Lu+0Awzr+pN88e26vvGH1MrwKO0q843cBObOlRzzXS1E7o8fPO6fdHTz3BDG8USxrPBHCbLsx74u8U9icvIjCXjwjwtm8B1JrPAKR/LqQpUw7hE3buwJ9n7nTdaw7/nP2PPhmNjzU17i8dcNOPAW2qzwUSCa8KRNtvHx0tjmlgzW7um0HvXEidrtVZcA7PRUKPXj+LjxH5y08VjeUPCzGFLz6Ayy8Oy0gPFH7pzrAC0a9jfBpvA/6DD0xijK9jkQSPNXvLLzARKs7VyOZO3SdL7zB5ew7yKsfvJDOEDxjmoI8waU2PCmWZbvL/Lo7Ls73O+sEFT2aQ687rnXEvN5Ksbtex4O8LTkrPYpGW7r/SP07qfdYO0kyZboOkNc74tMkvELOHL1BC6Q8b0mnvD6UxLxNFXw8R9MZOrtLkbw1UbK8PqjaO+o3ijyAye68RGEEvaNwCzysque7d4GwvFsMsbyTOsc8WCTXvIiPqzw95Qg8UPZBvCBSxDwR+w27Sx8bu2gM+TzEBKK6++kqvRTCJbyZdzk8JzEPvWM+ObyuKnY8ndmPu8HYQDuKg+071C9OPOGSirzkakS8r9PWvHCAabxyVWM71SElukGUUjxkBvm7m9w2PMBY/bv3u468csWMvH/5rbxJrPK82JkHvL6127n3QaK73SADPR6syTwN1Y074d9Du9lukjzto5S7zVrCPBDFY7x0Xq874uvIPOx3wDoeIlc8EnAKu5SXxDxWGAq8GruUvPxKMDyYPa48rYyGPM8BfbxAdCS85LRYPDnm/Ty5Aaq7WtPSPNk4OLwprIq8ZWrou6SkkzwzzBq8iiRCO2HSxrw3Yok8WoJ4vJWwkDzmbWY8fg4mvOw2KTwt/qk7L5iRPOVPkjwt8ia8pWwpPcKkGb3ckAa8McYCvCKYqTxYoYI8yPhCuwih+zw1IZW8xljFOmqYvzvy29s8KcAJu+POfTzxxMe8QBIRvO4yhzrSG5a7aofmPMs8Aj0k9pQ7mOcgPVRb8LoZOgq8+zyePCrcabvUADW8UI5YPNqCM7y1Cka8nZU5uiSM1zxXDnY8H3k/u3eEirxm/cm7UrXjPGIjO7wbyNO6UDCvvOfMrLyRPRe8etABO3kXGjw89gA9ZfZEvf6gV7zx8L28W5hEvKl7Czt8Rwu94EY0PPoQRb37Dlk6KC+EuhEIXbwdsZa6y1sEPeSHqrvhWnc8frHivK1qsrsxiOO8PQAHvLdYyDwvI067nXf2u1Ed2Ltc/UO8ozxGPa8UlLuM27Q8yNe1PHjwqryxPYY6GU8dvaRUD7xn+Cw9+qvLu0EMhjyzCLc8yMQaPHYikDuubN25s3OTPOB9UT2qxKu6qbeLu2Vbvryz1Qs822gcvZM3nLylVgC9HAH8u1/BurymdbA8Qy0rvFsyhbxuKtc7BRiGO7A1pDumzuG83w5rvFvlIbzW/f68RoVxPKMqnLvtbbe7trKkvHQivjwh0Au8m2A5vEcflbzfLQO9MDGBvG2ukLy8JNQ8JNEkPVTpwztHB/+8lOZiuydJSD2sE7u8zQOVOz7JKLwa5BO5bzuePKu8lDx6z7W75hCnOyOFkzvZoK28W3vZO0R9irtgHNe7FjjYvAC4EruzNtu8C2WVvDZYMjzXQkg87tyZvHXE/zyXF5K8kpmwPNrLJTy68u28+xZauynELTuKYkG8smoluzajT7ydMoE7WxgivXknqbyZBi290TuUPIFwWLzejJg75x8rvUSHIjYNYX289R/1O/+XKLwE0kW802UJuyW73zxSMO085KhNvPd+cbylnRu85p9VvEg5srxzwjg8IelXO2y8vDwFJWY8vKK/PPmVIT3H+VM7iWOsO8TI4DxbCfC8q84avIHkTrycUBE8q1uOPEaBt7v56iW8w8SNPDoFRbzZbgI8JZ9yO1Dwj7xuIRC9Dx2tO+HyET05KXg8BlQ+vEiFgLwaRr07+Kv2O4aXtTtAZ4c8dhCru/Acj7wKGZo8jjlfvLZjDryy2N88w5dDPMkxj7wtG1W8pUj9vNs9g7yJcsy7QjuBO1cFxbuYETG9AYi6udhYbbsvSOq8yofkOrGSlDv9R7y8Kt4WPPjbmDx9BP06plWGPC91ADzc+R8933LVPNeU0jwMNYC8tX5fPE4ZD71uSL28kmlhOwI8Dr3rnGA85FDHu5mC1Tv6+Jq86FUuvKkfoDp8s428NDQVuzUpELwBSH684dkqvQ24qbwFnSE9wx6qu9CiijtzUjU8EZXZuxOnnDwEsxs7uFTpvEHn2bmkEiA8hzttu1LIN7ph2ak8oodHO4q6srtsIw880p4xvOVB5zqR40m8i+WAvOZkyTxTawI9jR8VO8kG3jl35Bg9qgcsu8yfHLyRpyU8yZnFPHxOVLxv0Be7iAcGvPFH0Lwk+KQ893NxvNN6OjxIlz8735+TvHvZcTzG6my75j7XuxWTszuUv+y84qCRPC92N7zRcLA8LiOLuhkzl7uOyXQ8YUfmu0NbvzuRr1861La7PCM4k7sOK/Y8CuMCPK6pxjtjaeM7IHcTPRAYxDuLDrY7Qv2DO/e6frxfpC08HkcxPDd55LsKNws9m5pEu79C4bywJDi7tWWSvDKSPz1Fzry8e3J7O59NW7wtoLG8/sNHvA8TsLwCBCW8Sl/zOyPlKr2Xwfa83g4uvK/RL7wEvUm8NwxRvIiF9DvhDA88PGkBuc1g1DrL3ks8dxjYvJlzOLrPhwm6TqaEvIL9/Dyo3fy8y2k2PCvk6jslGgO9IfX7vLNppDlQ8YC8xfeLukaWALyuH5O83Y+HPKP1cDwIHaG8cm7fPKP15LwN3ok8sdTWPC4LH7wVSB08Q3ZOuZhagLuziDC90vsLvcx8X7w85Q48AD+dPIqlnLxjDyg9QZOAPCgnCz0Vqio8doyDvF/ArTxUZho8ptwlvNuviDy0sem7mf1fO1NfTLzXeQy8U5bjuwL1DTtBRK65IE/tu/kjBb2GORA9QzteOvDJWrxA4sW7SggzurxLHbwfOcE7OyllujKjmDuurxO8i52JvMyZwrviqrg7j+XLO/8/zjwx9Io7FDXCvOrmcTy6Ruc8Pdilu8wkS7x2DUm8vQ2yvGoO27shWng82q7svOwgsjxIlYQ77P++vBDYqzwjSiQ6iOhGvASLbLz802C8W3ZoPLsMwbwSci08uIgdvQvDA72nezG9I76kPCj7IL28u4K8oS1aO2hhN7yTmBm7hMrvvNlZGTx01iS9ZgydvCBNCDz1Ej+9+Rp5u4FHDz0RiWC7cjKqu+SIpztm5Im78GUYPIw7qLxmnAy8pvY0PNxtH7zDG8q8EQjKPF/tJzwJ7Ag8XYz0PCb0+7oZGL882GQdPAOUSTxF01M8Gp8PO0ghPLvUGtI7Rqm3vO+zpTxjJ0u8LwJKu1ADujzNNxk96KuWPLXhMLwsGZw8zKp8PCiaGDxjeYA6vme0Ori5/Tv3fQK9cOCXPIUvxTuKxqM8rKAkPAqKxrxkegQ8eD7zvKJGiDwBHEK6I3mEvFfL2Lyl7oQ7A2OMvEgioDvVKR+8ZivoO0dzYD3ktKE8DeeHu6Uolbz6zIW7ZmC+uzcz17wKaRo9aFM3vZXwTr2L74O7MNKYvOYefLwOPA27yOtKPPiJgzxh4SY9MeIeveSt4Ty1AJc8CDGkOxiSbTpfR3i8t2EDPXyoI7sgR9U6UmPdOwteCj2u1ai7cJ8bPU50irsGNjw9ngfhu7cZOzzoaPy8lOlyPLGkMDytjOE8bpomPb8zG7xkPCo8DZuYOww8zzy2oS08IpB/PByRRbycmOW73OfUOxQ6lrxJkmU8iFmfu80/hzxlnKy8yHvwu8Y64DsAz6o8bZMXvTWc7rlyou28X++2vDr8LD1BPIc7MSJBvPbkBz0E2hc8liwSPX1De7xVqGi7LBCSuufFyrxUfcC8Jf8RvPZruDvmeaS8fVUKPRC31bthQT48ZKUHPTruCLvO9s67sDI7vQ8HjLyyfUK8KZA3vI9JJLyDf5s80IlgvMlP/Dxbuy68MrwVvZhXBLt2bq68Qs4GPFvOVzpETiu8bh8dPMQQ4jyaeci5UjWau2fp17k4Isw8bkkEvbhGX7zxZDU89shzuxcL0Lz32RG7pVJTvLkyFDwyOVU8F6iUu4lvC7xyhFu7/16wPLy+5bxDCSI9M03WuiqbnLxubWq8UXkdvKK8s7wJ8Iw8iLKBvBRocLwXlTw8e/c4PDZ8Fjz/hOm7YkOEu3EzFTvvHm67noqMu6T2TLstpGy8gq7Xu/ZKebtkQhQ75R7HPNhw6DxVDcE81Nm9usEH8rzVep68DQ8fPA== + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 6 + total_tokens: 6 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '86' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - full batch doc 2 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 6 + total_tokens: 6 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '86' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - full batch doc 0 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 6 + total_tokens: 6 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '86' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - full batch doc 1 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 6 + total_tokens: 6 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '86' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - full batch doc 2 + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 6 + total_tokens: 6 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rebuild_full_flushes_pending_before_source_rebuild.yaml b/tests/cassettes/test_rebuild/test_rebuild_full_flushes_pending_before_source_rebuild.yaml new file mode 100644 index 00000000..2978552b --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_full_flushes_pending_before_source_rebuild.yaml @@ -0,0 +1,162 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '87' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - plain content doc + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 4 + total_tokens: 4 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '109' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - content from a source that still exists + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 8 + total_tokens: 8 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '87' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - plain content doc + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 4 + total_tokens: 4 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '109' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - content from a source that still exists + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 8 + total_tokens: 8 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rebuild_full_skips_document_deleted_mid_rebuild.yaml b/tests/cassettes/test_rebuild/test_rebuild_full_skips_document_deleted_mid_rebuild.yaml new file mode 100644 index 00000000..0b955c6d --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_full_skips_document_deleted_mid_rebuild.yaml @@ -0,0 +1,42 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '89' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - doc that disappears + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 4 + total_tokens: 4 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rebuild_full_warns_when_source_is_missing.yaml b/tests/cassettes/test_rebuild/test_rebuild_full_warns_when_source_is_missing.yaml new file mode 100644 index 00000000..64f0845c --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_full_warns_when_source_is_missing.yaml @@ -0,0 +1,82 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '99' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - content whose source vanished + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 5 + total_tokens: 5 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '99' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - content whose source vanished + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 5 + total_tokens: 5 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rebuild_warns_when_post_rebuild_vacuum_fails.yaml b/tests/cassettes/test_rebuild/test_rebuild_warns_when_post_rebuild_vacuum_fails.yaml new file mode 100644 index 00000000..b2c74d49 --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rebuild_warns_when_post_rebuild_vacuum_fails.yaml @@ -0,0 +1,82 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '88' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - vacuum failure doc + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 5 + total_tokens: 5 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '88' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - vacuum failure doc + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 5 + total_tokens: 5 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_rebuild/test_rechunk_raises_when_docling_blob_is_missing.yaml b/tests/cassettes/test_rebuild/test_rechunk_raises_when_docling_blob_is_missing.yaml new file mode 100644 index 00000000..e46e6ca3 --- /dev/null +++ b/tests/cassettes/test_rebuild/test_rechunk_raises_when_docling_blob_is_missing.yaml @@ -0,0 +1,42 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '93' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - doc with a cleared blob + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 7QdtudPk0Lx653w7Y7VdvDBkfrqgsfk8K2PEPGkUpbxUfxM8AICSvALDCL0KW9A8B/spO0t7IruAyrG8Fn7wvOagfTw1vxi86pCgO0gEKLpD2q28ehb3PNbMUT30F8W8WlQmvTPOBjzEQKu8RS6IvX5yiT2GfLU7t0uEvWtMZr0pUBE8BvsmvPuYYTuacC86cvUkuo9yQ7xsWhk8LnYzPIXO+jwfVSq8rujkt4bpQrvkmHm8n2GrPH67Mzwjg1K8j/YGvW3Ty7vjICI8v7ZLPC14U7yL4M28arO6uyz9jbr4tQQ90GerOy/5qbw9ega9RtNFu6UM9Lq3z7E7BBhDvGZIybpYMZu8WXeUOxD/NzitLwO6XKlnO9lCiT3O6Jg8l7Cmup1BZjwgGXW7X+cAvfAaH7tjPyw9SE2fPE/lNDxpJRQ9CqACPHFk4bvvioG8CraHPLki/LuqgqW8NvalPC7CuryEmjY5PHYKO3K28TyvAVO8+qUePR1IPjpCOtW6PrEhvDCyErykTMq72Y5tPCU5EbzJPvM7clbJPLpTQLyUqCY77e0nvYbKWrwd7sU8p7oZPBUrkjxemIC8m9I5vLhyhbuhWyC7Nw+dvETJLDwkJVy8xMTBO14B3DzjGlU7IQm6OwgXzjuTLw+6hmGQvF58hzvAycs8mocgPMrUDLz1Fxw8kkjlPNzJ2jrXtJ+73N3kO8ay5DuQwPe8tiRRPMhyEDz2v+e7Hw7kOjmV0roOOcO7W+covJw2eTzGTgy9Dv5pvPYztbzJzBe8TR9lPA/ktTuaqb662lVGPLdRq7y+u1Q7jnZaPGz4sjoBT9c8KVtFu4YXkDw1Jyk8+mXDu9ZLc7vomYc8yMumvH6+Mz1/mUY8Fn5puxU5ALxUPiQ8/ClSuyRNDzxmTac6uTnWPEj3gjsPDWq817xtvOZ1Lru328y827eZvNwaAry9ozw9YlsGvMLnbTx/szC9NWj2u6RJRTyBLJg7zo70uR5+Trxv6hg80Ce/PMoRMDxANky76EUsO4xTY7p0oaC7LN6MvEAghrzqyfY8LdNaOhLRlrqUaJ08ZsZCu1SAOD0/8kq8UY6quktAhLs3Lli6UtE/vAz0XzwCo3a8c4gRPO64kbz4v7e8dw7UPIN2WjwQ15I7LNTdvB6hibshyrs8OP6HPFSYpLtwrQ47+ungvAVsiTvYctW8oWV1O60pBzxVgS28H9zMuo7v2bxqLFM87DyGu2GpkTk5ALa8AfkoPFkpvDv1OYg8ttfsO96cCzy3bnq9Swiwu8IZKzs7IR87q9/MO4d8JbvBZuq7psNYu0l14zvBsl+7FeavvNc0wryXUFY8RdKhPM8yDbxgxCK9JdIAvCFsFrwkTac8uihfPFpfALx7eqi6bzx6uxvQPrzXkNy7TBV8vBnXLr0GDlI5+VxtuE7gm7uGSKe8m9N9PEdxFLv4UYq7jvl2O3u6ujyI42+8wqQ/PCalnTytrdE7bYT3O+9e/rzs9KI8fiwpvYofObt2uK88c5O9PH4qmDyz/gS7Ft2Lu66nD7ynBhQ9fasIvT5xpzy9rZW8xdruu5RxLLzCSwg8Lcp1PKcYqLxvVcu869wVvDOARLy0TM87JY67PCaAtzxM9V48TndKvKdrgDwrA747x/BFPXIzNjzALYS84uwCvAgVsrzK02C74P7JvIAzr7xM8YO8QJDRvFcsarzocua7xIX6uyE3Cb0+u8277mSuPG9bo7tKE+c8ndG3PMWWlDyFaos8HhHAvMpu8zz8xp8777WYvDFWFbzyE4871uYsO27KEz3k6bS75J9xu3lcq7yiwSg7tlfWuoB56Ts59ya95wvcu47DJT31fG+64CHkvMkQojyJVw688bpQvEoDQbzBbUS8sZq4PJ6EXT3XMg695jhkOoOKszwxW9Q85EEFPNiRn7xJMys890+zPAPDn7x3dPm7G7wLvBYGnDwkMnM5JQKyvN+UrTzAqac7GYjKPLDzSzydSbI84w3ZuxGlAby9qJq8dtB3vKdsXDzG/VA8cxTyvBAHHjyXnpM8jFvdvBlgFTz8oza8Bd/gPEURKDzg3EY7WTWfPPRHg7zPc467BX2CPcGkqbx4zfs8CXRqO8+O1jwjevI7T6iCvF+nMzyRFCK72iomvH31Q7wcZRy892xMOnKTjrwNqsQ84/fwPFAvVTwkwJW8c2ZCPA8SjjutGwa92PGcvNjS0zy2Xr48OYVZvQlrpLwi/7U8LW8SvIRQgryHke27KMzPOqq20Ty5wTa83HQ1vAEMj7zzG2i94bwOuw+eQbwWxNM8BAKrPOoUAT3V30i8RiTrPHtdpjxmThG6gwNtvIKRI73I8C+8zpUJuwqbqLqXOCo9/S3XuyiUFbtWJEk7pwfkPIFV2Dypg+y8WvALvdGq6TxuUtI7Sa2tuoM30LyF9507nXHfOxzKDL0tGcO8NNTdOwP4kb3qSVK7OqpJPDnvz7unriS6qmXAu6r+0rywEV47/d8dPApbazzycgG8PVqYuxUOQbzmKp07eaICPEFAhDwAwC09MwVLOsFkJjuRIJs8jncLPYchybycxns8FR4vPZJRxTraOfg8zowOPSUdTLvASFi7EytUPIT5STyskCO8sxzpO6sm6jvHbt+8eqftO3mf0jt6DaS8U/BRuw5kEj080/M7t6m0vKQ16LoHRUI5pevcu82+ozyaBQo8qeO9Og5N6LqiSvM8gFqVPHOcALsHP6Y7kNkXvf4YXTymroG7A0BfvN5O0byjMBW9psLnPFIdWbyO0UE9ziToPLGj67yuR0Q8heyvOylKLzzv/y+7/u0ZPdBZ4LrTMwy8RbgyPA9T2DzLK2C8PSPSvJrrXLyHpwu7SJ2nOWqIAj1nqY88Le3kuxEVAjy/4X27RoIQvYG4fTujMvQ8pthXvJYKrbuGsoa8rf/MucS6Sjwqj9S7WUuCPJEzazzLDHE8vtgbu/F0q7yHtSu72ulrvDpXjLxT84M7N35cvHFpIT3SPNA8ThgtPaKl37yYQaU7nlnTPMv5XzxKSBU7gQ89O693FDx4j8a74nANvPJTurwTmYq8ALI3OwDFl7sSMoy8SRIbvAOLLrxD58w7ivVQvA7+vjxndJW8ny5FvGwVjTvXpri7bpcUuwc+lDv/WjO9+pzpuu2D2rx079U8iOZDPBoaUrwkGvS87ME/vfqgabyinCE7r5utvMvnO7tZIjy9MtrpOxRvqLyKBT085mEDPYImKz1AHIC89DAkPLynq7xHJoM7qpezvIyLkjwygN+7r70mvL+EVzwuDL67KmmnO7seFbw2MhK8ze3CO5vfgDwDFl+6EsDKumYr67zSws28xViku2XhPDoJeB+7b2akvIU8wTzYhvg883KNvJoA2jwlPH+8NsGovBgtCz2OdQ881oqhvGqXuzybEIg8TdClPE0yjrr8NFA9FygJvWQOZb2fa+G8Jw6WO4d3vjwEtsO8Wj7YPD94s7trw6O7Ac4CvR9bpLy3qrA8I9iSvCVOPz32mxi72KqBPOxaBb2kpqA7LxG2POU1nLw4Ex48zNBEvFLL27kqZM48OCfgvKDuLjsykhW87XbEPDBeKbxOZ0U8QQU+va3MwDuuFeI8gh6vvHSKmDxA2wQ91FqJPIRb6DzHXuG6PsQWvEHipLx0wfw6KNI+PGN/3TyXZfE8TPzRu8tt57zXGQ49e+mkPGicYTvoJ6o8fa4uO8QYXDwYD7a8fWk8vDvGG73/qi084omeO1EB1LtA95+7ccSNuu93vbwyoC28LtQ6PLnAETx3dQc9+Dj0uy9s/DoXfIK8PvJhvMsH5TxFrea8YAYROxiRrzvzOA+8pkq/u9NFAj29vLG72kFtPLpAqLvxEw272qFsPXrDrjyitaC8F62YPUm9ljsLOBo9vtKtu2XkRzxoRhy8Ep86PLOD7byhMPe7Y96OvJ1VQTzacFU81X2qPOCkvTw13iW8ww7jvD2dyLt5vQW9qcNCvD5wezw/FS4756ysOyFEJbwqSNI8XKvnOjclAL2lnS08SQkNuwZU8zy9XAI826uCvLAMFDs+Mu28SShBvOPX/rwHkZ28HwOdPMcdObw3afy8wT5JPIbOMT1zGBq98TYJPZnITzxB8OG7qoCLvJAL1bvhZ/M7G+gOvBtgpDweXg89JaIQPMM6EDtsGJY8YscvOw0EEbyzfyK7Z3+ovL+GzTxX3rS8J1XBvHfpl7uhBfa8eS5SvGbYszyPJ7a82aqXvAGgrDzYFNk7897zvIkOuDwfrei8wp+pummIrzyLRuI83wm8PJMKajun+Uo8mv9HvFQGubyE6kE782a1PB7MRr0B3bo8lGqaPHvrn7zWxAy9PjxZPZe5RDweHpC8t5B9PIXAcTxgEWw8t6W+PGUkzztp4zo8MwQgO99DYzzTGuK86z3/O+OdmztWlRu7unIcPB3ciTyWRXA80jShO2Zumbzta5K8ff4vvHVcHryTpmO8+5w5vH7/UDsJRdk8tyRpPHpbv7srgzM7u2JWvNLF1jwqZyI7aRiLPG+KPjzLg8E8WpziPLfNrzzz4vW5vpgyPY/itrsDova8ES89PQsdPrwgPyY9i+O+vGKo47x023283cM3u+lpljwbVjM8UI9XvNSVEj0ZmZO9viEQPQicqDz4stY7ga+xPBuwd7w0RT67dhlnvEHGQbxcjDm974X1O0FW2zzIju089C79PHIrMrzJHgG9O4GhPH9WL7z/eSm8YMvgPBn3WTyrMHa68p1tPMVQYDzd+u27eNFEPMPB47vYy428XpoavJlJ5zwH7NC8l4ununvNuzzqEy67jXpdPF2k5jxY4ga7SENgO0BAHDxfKAO74s2IvG7eJjt3W9g70CYIvHnvgDrle468aUkFvHDmpLwQS3o8ybOWu6VN6zugvPs8cvZDPGysr7w07z68ssSCvFYDYTxi/068MF4YvDyFo7z1uXW876LBu5DcZTw2FYu8QuoKu+6Lw7w/NGc8BbAXPUd5yzwwXAA8YnqJuw21+rzLHzO8OKSlPIg89Dw2TVY8/ArSOwDEKjybBBa8bGIEPJFOtTtmy5Y88STMvFisB7yV0727ouieOeqmQLwyOfw5zyzSO+W1g7wpkhC85o6vvKf/RrvlAza83wygPCW9Kjy7MrK8ElM4PGOMQby4zpk8JvlVO0DRtbz+An080E5UOxH2/jxcgV68vsrsvNPZY7oVpIY8YMuOOWF9L7tHpWk8O6xlvNWELTt8DVU7Yw7Du+TRFb2A18a7L8SNvE5nkDv+moS7TzOxO3VZ7rpRPzw8kqAdvOe1ZzwmAXE8PgG8uxKGwDtGj8Q81aPEPFYj57qabMA8uga8PCYDHLzsM727/pEyvCpghjvggas7C1+3PJY8pjqHeG88LJhvOzxpEDx44d28694/vDNYZ7wd7em76FUUPYurN7x9sWk8beeovMFVmLrJD1S8mMMLPNbAKbxcNO68kb8HPeTVqzuRRKO8tkLFPAW9qjzpXxg7nhTWvMabs7v9JGc7QfikvG5/gbyh1gQ9RSyUPLFrEjysni69aWNSPC7qhLxRIm+4IR9Iuf3FKjv8Sgu8CRukPMixUb0QjYs7cLK2u9llwryKS0w7ddcpO2NusLxqZuk8DTGFPBZrrruPJRM9ktOuPPUHBT1gxJi8wG2RvOmSIL279LI6VHH3O0yBTLyXjDw8OPIxvISfCzyzuBK9wf+lPNGGVDv3wz87uX3gPLf2pLsuP/+8oKk9O3lGorx+cm68Z69Hvc1HPb1tWbW8D2nVu8ZAADs5+gi9JGD7POc+njuo1SG9oyM1PNFEprw1Ik672S7TO2ghqLzfvbo8f5yFu2AJM7ydBXa8G+mvPE9ZkTw7dAO8gsS0vNfOjbz2ZQW8RP7ZvAFLIL0o5wo7LLzcOwL1SLz2neA8mE0fvaJhhjz6QTW8T5hjPO9kI7uGnYO63fYgvKQExTzIDGW83+IivGRzurxiLvQ8tyPJvDC08rrrm4a86T6APJ3Xqzz9Yfi72TppOyFklDyQDvI7+a3ru01DbbzfQIW83DaHu0I5PD1PIQC9L/qzPJtdHjz5O4i7RLpuvFjGNDs9H5U8FafLvHDoaTxrjjU9RjUNvPN72Tt/osW8RdmPO65oTTxrMPA8LPZ1PHAPMDzBICo89rn2u+S86DvT8V88EpPTOo3s47s6z4E8EBIKO57VlrqOyVi8ZeHfPEBu07vBmUO7zs/tO7rftbs69oo8yujXvOIXGL2ZM3E6FcihPEYiLrwFsVI8audjPV3kLb1a0OU89SWiu2MJ4TuQHIC8qP2gPPaPhb3GMBW8P2acPLRWjDpkm0M8mUyVPCSt1rwgPec8/Ee1POrVGDs5lMW7G8J+PAFQd7y4CDe7N3aBvJs0Lrt5JKG8y8ruOn4C0rwNP708gFGjvItEBLs/t6M8IKHFvO5RRTzyOj483RbgO4naAjtgIhS98bO8u8nOgTk3iaa8mlQmO1lh/Dx8UNW86aaUuwTJxDt0kBi9kI1FvL8DHbthvQS9VWbuuxNZFb0ep7k8m8AbPQ7/rTwWMzy7BTRnvOAqtjxWXim7ZySwPC0fybvsTZs7h7jTOrRVKb1w75k7n09kPGvVYTsCS8s8OPubPBVy4LqXkp48VEBOPJn3tLuGLhi8lH6HPAMoBL032PO8ckrxO0pkvbyvkQe7dNe0vNOYiDtEqls9X2hTvNQKB7wfZ+47HAMPvQFk97skTn67X504u1TAhTwhL9i8K6WWPG4amjs9K4a8IDexvLUepzywos88AT67PKzOxTx1TPm8ZQ60u4iFDb3tGmc8xcG7u+RnqjuI1ow43Q8jPbaYMzwtTYe8pdFcvKQvaLzujRC8VnHBPMCxHr1zF4q8UbGSOoBwbTwArQK9LROpPEfIJjxr14K8aO7GOhlHsrzjxDI8Sw9pO/rlrbzXQpi8fbFHO6TjgLxVVmY75bB4vNSgzzvbLC08Bfk/u39k7bzwxsG7GcL0O7btJzv/GI8850dmPAuw27t3h/68OVfivEw4JDrc2XS8bkkqvdnAmrw6ThS982rZOyA54Dqu0o08k/qauuVbNLxcE845RSQyPB3MLbzCvdo7RPC/u/NoojyBBWO8wJW5vAIFHjxkn8c8xEWAPUEtpjwu42C8+OnPvArw9rzf9KI8K34YvDderLs7o7u8Xb/ju+DB9jzVNpe8jfgRPD6cGrzqfHw7RvGXvMwzK7uEEwA9psk3PIcZXzwXkjS8n8SLuvM7UTyJ0Oi8brRVvJKCfrxlA748+hOLPKdUFz3l94w8JJ8AvDGsq7wIfq88qGRxPECDkDvbjIO8A+7kPIxcWbyA0hK9aNlAPE5IbDxqTam8kuKyvGyhqbrMmV08TFXPvORLgjwt+Sg9eTcPvMZBmzy6zI48Xfo+PZz+0bvJUvS8pAM0vbbz3jxANZE8nS9kvFMK0Tz6lh+8pQxdOwTz07uteKk8aAIlPH80Kr3c67a8Bf51PPjZ3bxNsas8hfguvUO32bw0uW28ln92PCseWDw2VNu8uO8jvOe9WLtfV/Y6KogjvBfORL0lPD+7skrdvAjGMz0x45C8FYoFPDFTyrtB7tE7MzuNPMqZIT0Awhe8YkmRvGVrn7yNJBk8bvnHuxKAhLo1sHG7x3ekO36pOjuPQFm8K0FFu9yzsTzAs+68y49JvOG6kjtORJ06j0giOpZDurwXjMy77wWXOxdWvTxs95w8yXa4u1AEejzGSvi7wzATPN9RZLyO8Dq8RIyTO14KTLyXgbm7T98oPKLlhLqWl748jw7Lu/J/ArsbKYO6tgnnPB2bvrxjkMm8Rw+4Owjt2DszoT69urYAvGKG3zx970k7sAL4Oz2UDj1lrzU9CN7AOzEtVbtNu5s70L/AvKaIcLzqztw8EaXvPBbF9br5f568oasYPK0gTLwVfDU7JMGUPPRviTzGvhI8ge0vvLgvozxAoXQ87VmDPO8LCz1WKUM7pBUxu1grLzzXnfO8NKUxvCU/XjovDJG7mvoQPTWTOjxRj4a8hSVhPH/4gbzAJAm73yUqvNKXFz26iOg7/MVKPIn/IT19HbS8ntKkucu5Qjy1KYU7+GWSu63WITywzww7U1GQvGuxZrwoHQc9p64kvN9Skzqd86g8V9OmPJ8gnrtFOO470g9JPLvnhzv1MRE9brnRvBcNNb3Hqzg9MlykPMnXi7xH/KQ8VpKdvGDq2jyJBAw4ELG8vCcEYzuTcT0967COvL39DDyumpo8CFEMveiwHD3JXsE6tkErvO0HgTyiocA8x4e9u7TPwzx/Yjw9yfRbuV2ufLy6RqK87Q00PBblsDz+0S2962QBOiD1h7vtdCA79GOKu1l2ijyKoWq8//WxPMS0o7yIVR28bK6TPN/Zvzxjuxq8p6vgO9OHe7zVb6e5LBg3O9b9GbwUljM8V1BoO9+mmTwkBL281ZpUvDP5R7sbZxM8dpXpOh+yLjsa0cK8gZyrvMRFJD2l3lS7ywVTPJyUCTv2S6K7tI4GvPJblzsgTNY8BxvEO9gNrLyFk8q8b51PPNjUZTzcSVC9/LhzvAZ6JDzcRl+8L3xBu/JHDryHjgQ8YmurOofgA7xoxiS8DVNXvHLctLuc/Y+8BgG4PH7y0jyZWkc8YlD7PKPjQb0e5BO8AWr7uiylkrvSgVW75SMvvGEKgbxXNEO77hlAvPPzIT2Xa2k87+azvBUTBbx1Tbu7TcXlu8C2azruUAw9gp5IuywXDz2UGYK84sJMvd+2oDs4Rq+8GbGwvESHabwxh6Y8OGuuPOrWijtq8oK7icwCPb3iCDwOl6C7zDiVuyFpj7w9Zs8823C/O23157teVUq8wWYsPeVZBDyngD+8X/aVOySIEbzYRfi8VLvZu+lp7rs0V0Y88RlZvAcAFD3YORo8O7+7uw83PDzS6t48+Ch1uxWYobwWSJi74MwYPauAFr0yd0G6ZCKxOpxYbLzjQkk8ocL/PMKjLbz7j/K8L98sPJjaRDt3YjY8nbqhvOihhLzcfbc6Bmi1vLYqBz35cSG6ltSSPO2f0zvTVa86k3Etu+RFtrzwYvK8Vgc3OSjg9Tz8uGU8NS2jPHityDuH5UW9s7tuvPh6arxUylm8Bz7EPD7aqjx/Wy29XV0pvY5hjjyFdR89TZluvBkzp7xjkKs8DAWMvD+imTzey3A9EhQdvZpX9byVX6E88b/DPH6RQbthesS7r3Kru5DBBzygpsI7wYp8vFy3IzwHuAq9H6XUPGIfjbyjIIO8qf4Cu5i2OrytkQW8qeMIvDgQjbwJufC8fx4NPcpwnLzojNa7GExjvPHN6jzRXQE9+Js0PHmpA71uJoA8ar3FO67Bb7xVFB68rOw/PeYzvjkCt1Y8zQjIvAO5ODv6sa28L+STvMyD/rv+Cws8WQ6yvBKpA7ouDre7ZIe1OtXgG72j4iS8P89gu5/Gxry4ROo8Lq/LPMbYCz1JeXG8NibJu0sdVj2G0sY8PI2uvGkBeLxCmyu88tR7vHQwIjyAHLw6fRzCPELG3rwtzSa7yJMLPbr6xLujtQw81UPNvHGtLDzhAgC9TU4fvCCptDz+H6e81vBROzoAn7z0FHW7ZePYvCphWjukIKm8gSF0vDSI5jzazd08omCSPB+zyDteyxw8ZkguvEZUpjsYFlk8CBTuuvQjJTwq94w8SSnePD20N7yw7dA8IJV4vAwXWjqSEfC7HVgjvSgSBb0f1sU6TkhQvLTI1Lwu2JY7YkoJvOv5qryqVsw8UaKDvCQYobsNNKy8Qr62vE0t4zz1f2S8PKwBPc4Lq7w2O7A8Op5jvB8FkTwrj9U73aHovLE2MjxWY9Q8y0LUu/7wNTtcoBA81Y0ivWZzpzykiMQ820f+vN1TAjtTlwo9Qk60PIwNGLvMeWE62b6mu+kUFbygWJs8Xpf7vKs1iDvTTXc8NPaSu2XDFTzCaba8qTrbvCmZODzDR/i8NzERvK3HXLsrmfq8f+yKu+9m4LsjTQu8ZOzEu4dX0Dz0D5E77eTHOyvLiTzXZnI8/tOqPMyGA7wuALU6sHMAPabhYbwpxX87tUtAvAoQHD1pnXE7TsCwvIdHSTx3XQm8Jq7gOl5+k7vGn6k8vEOQuzJoUj31AtK87/kdPb2KaTxxP5S8A/uLulisnbvmh5U6RoqYvHptSrz2ERO7U9wYvSliS7qiDO48OjAkvJXY57uEJS884t94u4nIsDy7fIS7OP8SPHUCoDlqiKw7GtUGPahoIj14HJQ8Xbt5OxEecjwtmi48uy47PdpZnzyeCY88WMSsvFEBnju8Dw+8snYzu0lZULzyTny8TwExPBaAhTzruca8TxumPJj+6Dy8AAG87oCSO7ThrrqB/2W8CDV1POaQkLyKQsG7mTK7OvWnsbuL5BO8RQLNvHdikbwOo7C8TgnLPAdNVjwe3+68Wdd2vNDsvbxKA+u7UQUHPXg8LjsJTcq40bq5vKbmDjxdwme8JofQO1rsojxPv1+9vH5GOy59C70G19i8Oh12vJ4NArxYcAS80KE0PC1JyztofO28uyBcvPHS4ry9gwy9/SBJPN7wxLt2DIY8ZpofPGSsvDtntq68AQSiPKMSxLy8ytM8rbWWO8xnhLydvpG8V8EkvaTWc7s15BQ9amXWuyr8nTzRvT090J/VO/NZhzngBaU8iaaIuszMcT22P5K7oN6AvEFtIzySIoK7InBqOgbxF73iEjS9aTsKvNQdzrx6mhM8z80bvKhQdLu5ofA6ZmRHu+OqBbwpjzS89buZvBsZA7z9bEw8XB92PBtDRLxw/5W512S7vHj5Ez3KTcW8gtQXvWSOLbtThRC8GPP3O6KQ3rwkeoE8o5sSvA562zzznwa8it1FO37RLD1TIcM6Czhsuvzny7pG9O+7LZigu/UpfbyvmyW8jpyEuzE+HLwZdOK8J9xuPNtaljtRLZo8cAiRvLk7MTy8Rt68M3Q2OkNWRj1fyAe8tEUTvNgSWzwbKYC81l4zPKTRqzykgZS8zvmJOz9lmbynQY48P3l5vF3OTTwty0G8QsJbu9l7VjzIGZG8uvSfPECex7qoFlO8df21vGOM+rtGTPy7uKLWPIYZsDuhC4e8ycg/vIqP6TwNTUq8fWTWuDNVzzwcU/+7VbwjvN8o97utUAc8Z1pbPN8L2jyN+G87XvFRvGTxGj3a1WI8rye9uxpaD7s7XdE7f2wzvGLDbrqTuuk8fEtUvDtx+bvM4nS7tTxcPEzGdLwaN8w8yXiFO1Fv2byqZNa757eCPJHcyjsiLre87O8avNm8VDywtpa8eErzuz2ekDwp7W881K/svKWlq7y6GsU8PrNmPBBXjzy8AFG7LVQlPJRkz7sbzbm7/9vnvJO0H70sYg+80e/hvJg/6ji9mli7GgBtPBCdEbxJxYS8X7rgPOJuiTyrhYI8/93UOpB3Irx8pOw8UNV4PC5ZgTv0XIi8B79pPBgMn7wuRf67M0wJu0Ftl7vCw+G8aw9EvR+KFL0BpBw7OIfNun/Gyjk+Rcy7BNWduwLXIbtea3e7bsjUvHUORLyDev+865cOvVHZUb2jXKE7QpsSvCGUSzswz7c6yCGTPJg5zDxWMK+74JakvLXZG71HCPq54RkpvCIMjzzzjJu81SL4PLBcTry7Qka8uxsVvGnmAb0DsqQ8+z9lvO10xDtZ1yA9vPFkvBA53Ltsyz27IPa4vCquOjyXPEw8h7MOPcrRBL3yBzS8BVBju/8L1LyubxM9apcCvQ3QFTxWEHc7kJuCuylViDxuqya9vpYNPReyrbs1wL075HqHvI32Fb1I4+o8VDeGPCvJ0Tvttmg8sjl5uz7ngLzOHxY8aWD+O3IzZrwevwk8e0yRPELhITygBzQ6ynwtvDRdbTzHNuo7BsWaPAj7drsHcMY6o851PPSCPLxXGbu7iwUZPag9ibw9dpS7TXU4vFSlrzyEUbO7oHePPDNqF73mieM7CaqsvEvq3DvY7zE8YsbZu+JDI719cE66rbiuvJuXs7xe9q64CkpQvButWbxM20G8a0/Uu7YT17xucqS8S42RvEndRTx7/2U8zkFUPJBS4DzkLhk8Ox9kuyFrajwaR/a8h6INvdqOz7qgNWW8YR7RvHXbWzuDjjg7k8m9O9sPBD1eTy+9vl5bvHfQ4Dqz3o27Sey8PN+3Kryxmic8seKSPD79jDvi4Qy9R2XRvGLiGr2XzxC9abpKvGxsLL1RIcs8w6amPOk7l7tVFOC7HoHFvLQI9jz99Km5WZbKvEcsgDv33Jc7TjaLPJT3gzwcDiy9tC/Tu8AZMz0GaIC8HY3YO8XeNr01L9k8hzb+PJr/pbzCpZ27axk2PCGKKb1MZQ29o3mCvOaIIDz/Hiu8AxNkPNYp0jvxeAc8YHwnvEOGJjwHIhI8VksNvRTrsrzm1pM8DKnou9TK3Tv1Qry8LEwUvZKenLsXL4Q8TiTFO2sAAz01h008XxBLvWyKeDxwoEk8gS+mvI8WJbvz4Ec8of8VPOSlXLxY6mC8wKjxO22XF73XaBO9q+8UPLzsurzHp5C8y9K4O+POV7zMHaA63NMBvevPtTvyQ1o7RyEYvZiXEj0dHae8fm7Fu5IZfDwNJBU8+jLuO6iuEL2Wijw9AT9BPJrLDrj9mRi97G7JO+bUSbwxO4S8sdU6O/o0bzwClqC7qRfiPCEcLrw427A8Nm7nu5nXsjwU5dc8zTfKO0dWCTzm2Uq96MqZvBpZGLyFpG071de7vByCgbwJ2ts8C1gxOkHJnbwhwzE446ikPLhyZrtTd+g7qwi8u1Waj7xAI6w8XEfBPDqAczxHbc08GOuFPCpnDzyy+Ii6aRsUvBrll7k+pqk8A6DgvF8pRzyji708I+kmvCiKbLyVz5C8dCLYOzY6bj26HIW8VtMlvANiQ7zBwQ68ccI5u0y3irxg3vU8O9sTvelGBr1m3LS8qRfhvOJPxTveCPu62EQyu7ApjLtbq3O7DVK5vNIrQruHOfm8gXVOO0i66bvInsI7H6J3OyFIVDxyww+97Pf0vJ6fyDvQIT+8cS6tPGtSs7snBkY801CEvNckqzxtV1S8lindO2zwmjuu7Vo8+q+Lum+LDL3BA8k7X7C8PB0Bmjy80sA8Jr/gOwjW8bu6BZe7utqlO/5ZJbxOlrM7rSXqOrXjmDzMhTq85vtKvIjeRrwrAUY8NtoWvY3NzTwS40686HZ9vCx3AT1H+WY8m88pPGdrxTxbYPE7mTWDPXonkjlB/C+8/c9cu2EI3byA2Rm9paTCutwh7LsPGGC8+jndPIBXOjrzVyU9ZdQMPZ2HLzptnZK7adUKvRjs3LzZ0Z28E0o0ut+9z7lPLB88NXoJPZ8Zozzt+Ru8M935vPAfWzyaQaw72BTxO0O3bDzoVqk8jzd2PCadZbs3JIg6Fzrfu1+ei7yHXc480dC+ua8QF7t5F4O5W3ldvHfSkzwOuRQ6xTJKPM7JiDsRNTI5sp+BPJqJRLx9/qS83LU5vI4jNTyU60q8uc+LvLUN/ru7i/m8cJwBPGktGTvhtus7pP5ZvHp5vry+ePw8ykgIPWclFbsXwLG8Yi5Fu1WblruEATC8eBWLvD8k07tLjeK88sQ7vRCchrrfBCa7Q97vuwGEm7vfzYu8vT8UvVhkobzfHpW8GcStvA== + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 6 + total_tokens: 6 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/test_rebuild.py b/tests/test_rebuild.py index 50ebc254..e8514b17 100644 --- a/tests/test_rebuild.py +++ b/tests/test_rebuild.py @@ -1069,3 +1069,383 @@ async def test_rebuild_blocks_tag_operations(temp_db_path, monkeypatch): assert not client.store._rebuild_lock.locked() await client.store.create_tag("post-rebuild") assert set(await client.store.list_tags()) == {"post-rebuild"} + + +# --- unit-level rebuild helpers (no embedder involved) --- + + +async def test_flush_rebuild_batch_is_a_noop_without_documents(temp_db_path): + from haiku.rag.client.rebuild import _flush_rebuild_batch + + async with HaikuRAG(temp_db_path, create=True) as client: + before = await client.store.documents_table.count_rows() + + await _flush_rebuild_batch(client, [], []) + + assert await client.store.documents_table.count_rows() == before + + +async def test_mark_phase1_complete_is_idempotent(temp_db_path): + from haiku.rag.client.rebuild import ( + _STAGING_MARKER_TABLE_NAME, + _mark_phase1_complete, + ) + + async with HaikuRAG(temp_db_path, create=True) as client: + await _mark_phase1_complete(client) + await _mark_phase1_complete(client) + + tables = (await client.store.db.list_tables()).tables + assert _STAGING_MARKER_TABLE_NAME in tables + + +async def test_populate_staging_returns_early_without_chunks_table(temp_db_path): + from haiku.rag.client.rebuild import _STAGING_TABLE_NAME, _populate_staging_table + + async with HaikuRAG(temp_db_path, create=True) as client: + await client.store.db.drop_table("chunks") + + await _populate_staging_table(client) + + staging = await client.store.db.open_table(_STAGING_TABLE_NAME) + assert await staging.count_rows() == 0 + + +async def test_hydrate_skips_documents_deleted_mid_rebuild(temp_db_path): + """A document removed between listing and hydration is skipped.""" + from haiku.rag.client.rebuild import _hydrate + from haiku.rag.store.models.document import Document + from haiku.rag.store.repositories.document import DocumentRepository + + async with HaikuRAG(temp_db_path, create=True) as client: + stored = await DocumentRepository(client.store).create( + Document(content="body", uri="test://gone") + ) + + async def vanished(_document_id): + return None + + client.get_document_by_id = vanished # type: ignore[method-assign] + + assert [doc async for doc in _hydrate(client, [stored])] == [] + + +async def test_apply_descriptions_skips_pictures_without_text(): + """A picture whose generated description is empty is left untouched.""" + from haiku.rag.client.rebuild import _apply_descriptions_sync + from haiku.rag.store.models.document import Document + from tests.store.test_document_items import _docling_doc_with_picture + + docling_doc = _docling_doc_with_picture() + ref = docling_doc.pictures[0].self_ref + document = Document(content="x", uri="test://doc") + + _apply_descriptions_sync(docling_doc, document, {ref: ""}) + + assert docling_doc.pictures[0].meta is None + + +@pytest.mark.asyncio +async def test_patch_picture_descriptions_returns_zero_without_descriptions( + temp_db_path, monkeypatch +): + """When the VLM returns nothing, no blob rewrite is attempted.""" + from haiku.rag.client.documents import _store_document_with_chunks + from haiku.rag.client.rebuild import _patch_picture_descriptions + from haiku.rag.config import AppConfig + from haiku.rag.store.models.document import Document + from tests.store.test_document_items import _docling_doc_with_picture + + docling_doc = _docling_doc_with_picture() + config = AppConfig() + config.processing.pictures = "description" + + async def no_descriptions(_bytes_by_ref, config=None): + return {} + + monkeypatch.setattr( + "haiku.rag.providers.picture_description.describe_pictures", + no_descriptions, + ) + + async with HaikuRAG(temp_db_path, config=config, create=True) as rag: + document = Document(content="x", uri="test://doc") + document.set_docling(docling_doc) + created = await _store_document_with_chunks(rag, document, [], docling_doc) + + assert await _patch_picture_descriptions(rag, created) == 0 + + +@pytest.mark.vcr() +async def test_rebuild_warns_when_post_rebuild_vacuum_fails(temp_db_path, monkeypatch): + """A failing post-rebuild vacuum is logged, not raised — the rebuild itself + already succeeded.""" + import logging + + from haiku.rag.client import rebuild as rebuild_module + + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.create_document(content="vacuum failure doc") + assert doc.id is not None + client._config.storage.auto_vacuum = True + + async def failing_vacuum(): + raise RuntimeError("vacuum exploded") + + monkeypatch.setattr(client.store, "vacuum", failing_vacuum) + + with capture_logs(rebuild_module.logger, logging.WARNING) as records: + processed = [ + doc_id + async for doc_id in client.rebuild_database(mode=RebuildMode.RECHUNK) + ] + + assert doc.id in processed + assert any("vacuum failed" in r.getMessage() for r in records) + + +@pytest.mark.vcr() +async def test_rebuild_embed_only_yields_documents_without_chunks(temp_db_path): + """A document whose chunks were all removed is still reported as processed.""" + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.create_document(content="doc that loses its chunks") + assert doc.id is not None + await client.chunk_repository.delete_by_document_id(doc.id) + + processed = [ + doc_id + async for doc_id in client.rebuild_database(mode=RebuildMode.EMBED_ONLY) + ] + + assert processed == [doc.id] + + +@pytest.mark.vcr() +async def test_rebuild_embed_only_flushes_in_batches(temp_db_path, monkeypatch): + """Forces a tiny batch size so the mid-loop flush in phase 2 runs.""" + from haiku.rag.client import rebuild as rebuild_module + + monkeypatch.setattr(rebuild_module, "_REBUILD_BATCH_SIZE", 2) + + async with HaikuRAG(temp_db_path, create=True) as client: + ids = [] + for i in range(3): + doc = await client.create_document(content=f"embed only batch doc {i}") + assert doc.id is not None + ids.append(doc.id) + + processed = [ + doc_id + async for doc_id in client.rebuild_database(mode=RebuildMode.EMBED_ONLY) + ] + + assert sorted(processed) == sorted(ids) + for doc_id in ids: + assert await client.chunk_repository.get_by_document_id(doc_id) + + +@pytest.mark.vcr() +async def test_rechunk_raises_when_docling_blob_is_missing(temp_db_path): + """RECHUNK needs the stored docling document; without it the user is told + to run a full rebuild.""" + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.create_document(content="doc with a cleared blob") + assert doc.id is not None + + await client.store.documents_table.update( + {"docling_document": None}, where=f"id = '{doc.id}'" + ) + + with pytest.raises(ValueError, match="has no stored docling document"): + async for _ in client.rebuild_database(mode=RebuildMode.RECHUNK): + pass + + +@pytest.mark.vcr() +async def test_rebuild_full_flushes_in_batches(temp_db_path, monkeypatch): + from haiku.rag.client import rebuild as rebuild_module + + monkeypatch.setattr(rebuild_module, "_REBUILD_BATCH_SIZE", 2) + + async with HaikuRAG(temp_db_path, create=True) as client: + ids = [] + for i in range(3): + doc = await client.create_document(content=f"full batch doc {i}") + assert doc.id is not None + ids.append(doc.id) + + processed = [ + doc_id async for doc_id in client.rebuild_database(mode=RebuildMode.FULL) + ] + + assert sorted(processed) == sorted(ids) + + +@pytest.mark.vcr() +async def test_rebuild_full_warns_when_source_is_missing(temp_db_path): + """A document whose file source is gone is re-embedded from stored content.""" + import logging + + from haiku.rag.client import rebuild as rebuild_module + + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.create_document( + content="content whose source vanished", + uri="file:///definitely/not/here.txt", + ) + assert doc.id is not None + + with capture_logs(rebuild_module.logger, logging.WARNING) as records: + processed = [ + doc_id + async for doc_id in client.rebuild_database(mode=RebuildMode.FULL) + ] + + assert doc.id in processed + assert any("Source missing" in r.getMessage() for r in records) + + +@pytest.mark.vcr() +async def test_rebuild_full_flushes_pending_before_source_rebuild(temp_db_path): + """A live source is re-ingested, which creates a new document, so any + documents pending from the content path must be flushed first.""" + async with HaikuRAG(temp_db_path, create=True) as client: + content_doc = await client.create_document(content="plain content doc") + assert content_doc.id is not None + + with tempfile.TemporaryDirectory() as temp_dir: + source = Path(temp_dir) / "live.txt" + source.write_text("content from a source that still exists") + source_doc = await client.create_document_from_source(source) + assert not isinstance(source_doc, list) + + processed = [ + doc_id + async for doc_id in client.rebuild_database(mode=RebuildMode.FULL) + ] + + assert content_doc.id in processed + + +@pytest.mark.vcr() +async def test_rebuild_descriptions_flushes_in_batches(temp_db_path, monkeypatch): + """Two picture documents with a batch size of one exercise the mid-loop + flush in the descriptions path.""" + from haiku.rag.client import rebuild as rebuild_module + from haiku.rag.client.documents import _store_document_with_chunks + from haiku.rag.config import AppConfig + from haiku.rag.store.models.document import Document + from tests.store.test_document_items import _docling_doc_with_picture + + config = AppConfig() + config.processing.pictures = "description" + + monkeypatch.setattr(rebuild_module, "_REBUILD_BATCH_SIZE", 1) + + async def fake_describe(image_bytes_by_ref, *, config): + return {ref: "A red square (mocked)." for ref in image_bytes_by_ref} + + monkeypatch.setattr( + "haiku.rag.providers.picture_description.describe_pictures", fake_describe + ) + + async with HaikuRAG(temp_db_path, config=config, create=True) as rag: + ids = [] + for i in range(2): + docling_doc = _docling_doc_with_picture() + document = Document(content=f"picture doc {i}", uri=f"test://doc-{i}") + document.set_docling(docling_doc) + created = await _store_document_with_chunks(rag, document, [], docling_doc) + assert created.id is not None + ids.append(created.id) + + processed = [ + doc_id + async for doc_id in rag.rebuild_database(mode=RebuildMode.DESCRIPTIONS) + ] + + assert sorted(processed) == sorted(ids) + + +@pytest.mark.vcr() +async def test_rebuild_full_skips_document_deleted_mid_rebuild(temp_db_path): + """A document removed between listing and the content-path reload is skipped.""" + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.create_document(content="doc that disappears") + assert doc.id is not None + + async def vanished(_document_id): + return None + + client.get_document_by_id = vanished # type: ignore[method-assign] + + processed = [ + doc_id async for doc_id in client.rebuild_database(mode=RebuildMode.FULL) + ] + + assert processed == [] + + +@pytest.mark.vcr() +@pytest.mark.parametrize("wipe_bytes", [True, False], ids=["wiped", "recoverable"]) +async def test_rebuild_embed_only_recovers_picture_bytes( + temp_db_path, monkeypatch, wipe_bytes +): + """Embed-only re-attaches picture bytes from document_items. When they are + gone the chunk falls back to embedding its caption as text rather than + failing the rebuild.""" + import logging + + from haiku.rag.client import rebuild as rebuild_module + from haiku.rag.client.documents import _store_document_with_chunks + from haiku.rag.store.models.chunk import Chunk + from haiku.rag.store.models.document import Document + from tests.store.test_document_items import _docling_doc_with_picture + + docling_doc = _docling_doc_with_picture() + ref = docling_doc.pictures[0].self_ref + + async with HaikuRAG(temp_db_path, create=True) as rag: + # The configured ollama embedder is text-only; stand in for a + # multimodal one so the picture-bytes recovery branch runs. + async def fake_embed_image(image): + return [0.2] * rag.embedder.vector_dim + + monkeypatch.setattr(rag.embedder, "supports_images", True) + monkeypatch.setattr(rag.embedder, "embed_image", fake_embed_image) + + document = Document(content="picture doc", uri="test://pic") + document.set_docling(docling_doc) + picture_chunk = Chunk( + content="Figure caption", + metadata={"doc_item_refs": [ref], "labels": ["picture"]}, + order=0, + embedding=[0.1] * rag.embedder.vector_dim, + ) + # A sibling text chunk exercises the non-picture skip in the same loop. + text_chunk = Chunk( + content="Surrounding prose", + metadata={"doc_item_refs": ["#/texts/0"], "labels": ["text"]}, + order=1, + embedding=[0.1] * rag.embedder.vector_dim, + ) + created = await _store_document_with_chunks( + rag, document, [picture_chunk, text_chunk], docling_doc + ) + assert created.id is not None + + if wipe_bytes: + await rag.store.document_items_table.update( + {"picture_data": None}, + where=f"document_id = '{created.id}' AND label = 'picture'", + ) + + with capture_logs(rebuild_module.logger, logging.WARNING) as records: + processed = [ + doc_id + async for doc_id in rag.rebuild_database(mode=RebuildMode.EMBED_ONLY) + ] + + assert created.id in processed + warned = any("no recoverable bytes" in r.getMessage() for r in records) + assert warned is wipe_bytes From 2afe1bd28c0df779e08801c3429717d2c12fb17a Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Sun, 26 Jul 2026 19:36:37 +0300 Subject: [PATCH 06/16] Cover store engine and repository paths Add vector-index creation tests including the warned failure, chunk repository get_by_id, list_all pagination, blank-query and precomputed-vector search, the unknown-score-column guard, settings row recreation, and replace_for_document with no items. --- ...ory_get_by_id_and_list_all_pagination.yaml | 45 ++++++++++++ ...h_precomputed_vector_skips_text_query.yaml | 42 +++++++++++ tests/store/test_document_items.py | 17 +++++ tests/test_chunk.py | 73 +++++++++++++++++++ tests/test_lancedb_connection.py | 45 ++++++++++++ tests/test_settings.py | 20 +++++ 6 files changed, 242 insertions(+) create mode 100644 tests/cassettes/test_chunk/test_chunk_repository_get_by_id_and_list_all_pagination.yaml create mode 100644 tests/cassettes/test_chunk/test_chunk_search_with_precomputed_vector_skips_text_query.yaml diff --git a/tests/cassettes/test_chunk/test_chunk_repository_get_by_id_and_list_all_pagination.yaml b/tests/cassettes/test_chunk/test_chunk_repository_get_by_id_and_list_all_pagination.yaml new file mode 100644 index 00000000..c4d2bfa1 --- /dev/null +++ b/tests/cassettes/test_chunk/test_chunk_repository_get_by_id_and_list_all_pagination.yaml @@ -0,0 +1,45 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '123' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - |- + First paragraph. + Second paragraph. + Third paragraph. + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 10 + total_tokens: 10 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_chunk/test_chunk_search_with_precomputed_vector_skips_text_query.yaml b/tests/cassettes/test_chunk/test_chunk_search_with_precomputed_vector_skips_text_query.yaml new file mode 100644 index 00000000..984de905 --- /dev/null +++ b/tests/cassettes/test_chunk/test_chunk_search_with_precomputed_vector_skips_text_query.yaml @@ -0,0 +1,42 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '96' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - Vector-only search target. + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 6 + total_tokens: 6 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/store/test_document_items.py b/tests/store/test_document_items.py index cee84196..ba99178a 100644 --- a/tests/store/test_document_items.py +++ b/tests/store/test_document_items.py @@ -986,3 +986,20 @@ class TestPictureDataPreservedThroughRoundTrip: after = await rag.document_item_repository.get_all_picture_data(created.id) assert after.get("#/pictures/0") == original.get("#/pictures/0") + + +@pytest.mark.asyncio +async def test_replace_for_document_with_no_items_deletes_existing(temp_db_path): + """Replacing with an empty list clears the document's items.""" + from haiku.rag.store.engine import Store + from haiku.rag.store.repositories.document_item import DocumentItemRepository + + async with Store(temp_db_path, create=True) as store: + repo = DocumentItemRepository(store) + docling_doc = _make_docling_doc() + await repo.replace_for_document("doc-1", extract_items("doc-1", docling_doc)) + assert await repo.get_all_items("doc-1") + + await repo.replace_for_document("doc-1", []) + + assert await repo.get_all_items("doc-1") == [] diff --git a/tests/test_chunk.py b/tests/test_chunk.py index f540528b..68c1222d 100644 --- a/tests/test_chunk.py +++ b/tests/test_chunk.py @@ -454,3 +454,76 @@ async def test_ensure_fts_index_warns_on_failure(temp_db_path): assert [r for r in records if r.levelno == logging.WARNING] assert any("index build failed" in r.getMessage() for r in records) + + +@pytest.mark.vcr() +async def test_chunk_repository_get_by_id_and_list_all_pagination(temp_db_path): + """get_by_id resolves a stored chunk; list_all honours limit and offset.""" + async with HaikuRAG(db_path=temp_db_path, config=Config, create=True) as client: + doc = await client.create_document( + content="First paragraph.\n\nSecond paragraph.\n\nThird paragraph." + ) + assert doc.id is not None + + stored = await client.chunk_repository.get_by_document_id(doc.id) + assert stored + + fetched = await client.get_chunk_by_id(stored[0].id) + assert fetched is not None + assert fetched.id == stored[0].id + assert fetched.content == stored[0].content + + assert await client.get_chunk_by_id("no-such-chunk") is None + + everything = await client.chunk_repository.list_all() + assert len(everything) == len(stored) + + first = await client.chunk_repository.list_all(limit=1) + assert len(first) == 1 + assert first[0].id == everything[0].id + + if len(everything) > 1: + second = await client.chunk_repository.list_all(limit=1, offset=1) + assert len(second) == 1 + assert second[0].id == everything[1].id + + +async def test_chunk_search_returns_empty_for_blank_query(temp_db_path): + """A blank query with no precomputed vector has nothing to search for.""" + async with HaikuRAG(db_path=temp_db_path, config=Config, create=True) as client: + assert await client.chunk_repository.search(" ") == [] + + +@pytest.mark.vcr() +async def test_chunk_search_with_precomputed_vector_skips_text_query(temp_db_path): + """The image-as-query path searches vector-only using a stored embedding.""" + async with HaikuRAG(db_path=temp_db_path, config=Config, create=True) as client: + doc = await client.create_document(content="Vector-only search target.") + assert doc.id is not None + + rows = (await client.store.chunks_table.query().limit(1).to_arrow()).to_pylist() + stored_vector = list(rows[0]["vector"]) + + results = await client.chunk_repository.search("", query_vector=stored_vector) + + assert results + assert any(c.document_id == doc.id for c, _ in results) + + +async def test_get_chunk_ids_by_self_ref_grouped_without_documents(temp_db_path): + async with HaikuRAG(db_path=temp_db_path, config=Config, create=True) as client: + assert await client.chunk_repository.get_chunk_ids_by_self_ref_grouped([]) == {} + + +async def test_process_search_results_rejects_unknown_score_column(temp_db_path): + """A result frame with no recognised score column is a programming error.""" + import pandas as pd + + async with HaikuRAG(db_path=temp_db_path, config=Config, create=True) as client: + + class _Frame: + async def to_pandas(self): + return pd.DataFrame([{"id": "c1", "content": "x", "metadata": "{}"}]) + + with pytest.raises(ValueError, match="Unknown search result format"): + await client.chunk_repository._process_search_results(_Frame()) # ty: ignore[invalid-argument-type] diff --git a/tests/test_lancedb_connection.py b/tests/test_lancedb_connection.py index 1d283557..23abae0e 100644 --- a/tests/test_lancedb_connection.py +++ b/tests/test_lancedb_connection.py @@ -310,3 +310,48 @@ class TestInitFailureCleanup: pass assert close_calls, "Store.close() was not called when _initialize raised" + + +class TestVectorIndexCreation: + """_ensure_vector_index needs 256 rows of training data before it builds.""" + + @staticmethod + async def _seed_chunks(store, count: int) -> None: + import random + + records = [ + store.ChunkRecord( + document_id="doc-1", + content=f"row {i}", + content_fts=f"row {i}", + metadata="{}", + order=i, + vector=[random.random() for _ in range(store.embedder.vector_dim)], + ) + for i in range(count) + ] + await store.chunks_table.add(records) + + @pytest.mark.asyncio + async def test_builds_index_once_enough_rows_exist(self, temp_db_path): + async with Store(temp_db_path, create=True) as store: + await self._seed_chunks(store, 256) + + await store._ensure_vector_index() + + indexes = await store.chunks_table.list_indices() + assert any("vector" in idx.columns for idx in indexes) + + @pytest.mark.asyncio + async def test_index_failure_is_warned_not_raised(self, temp_db_path): + async with Store(temp_db_path, create=True) as store: + await self._seed_chunks(store, 256) + + async def boom(*_args, **_kwargs): + raise RuntimeError("index build failed") + + with patch.object(store.chunks_table, "create_index", boom): + await store._ensure_vector_index() + + indexes = await store.chunks_table.list_indices() + assert not any("vector" in idx.columns for idx in indexes) diff --git a/tests/test_settings.py b/tests/test_settings.py index b2f11626..f30e2756 100644 --- a/tests/test_settings.py +++ b/tests/test_settings.py @@ -263,3 +263,23 @@ class TestValidateConfigCompatibility: await settings_repo.validate_config_compatibility() assert "9999" in str(exc_info.value) + + +@pytest.mark.asyncio +async def test_save_current_settings_recreates_a_deleted_row(temp_db_path): + from haiku.rag.store.engine import Store + from haiku.rag.store.repositories.settings import SettingsRepository + + async with Store(temp_db_path, create=True, skip_validation=True) as store: + settings_repo = SettingsRepository(store) + + await store.settings_table.delete("id = 'settings'") + assert await settings_repo.get_current_settings() == {} + + await settings_repo.save_current_settings() + + recreated = await settings_repo.get_current_settings() + assert ( + recreated["embeddings"] + == store._config.model_dump(mode="json")["embeddings"] + ) From 7c120587f0c78d3aaedf5b5553e2147263c6e5f7 Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Sun, 26 Jul 2026 19:41:09 +0300 Subject: [PATCH 07/16] Cover sandbox VFS reads, binary part dedup and picture spans --- haiku_rag_slim/haiku/rag/sandbox/sandbox.py | 8 ++- tests/sandbox/test_sandbox_toc.py | 54 +++++++++++++++++++++ tests/test_context.py | 13 +++++ tests/tools/test_search.py | 46 ++++++++++++++++++ 4 files changed, 119 insertions(+), 2 deletions(-) diff --git a/haiku_rag_slim/haiku/rag/sandbox/sandbox.py b/haiku_rag_slim/haiku/rag/sandbox/sandbox.py index 181aa2ff..07743508 100644 --- a/haiku_rag_slim/haiku/rag/sandbox/sandbox.py +++ b/haiku_rag_slim/haiku/rag/sandbox/sandbox.py @@ -356,7 +356,8 @@ class Sandbox: return read_toc for doc in docs: - if not doc.id: + if not doc.id: # pragma: no cover - rows read from LanceDB always + # carry an id; only a hand-built Document could be id-less. continue doc_id: str = doc.id doc_dir = f"/documents/{doc_id}" @@ -438,7 +439,10 @@ class Sandbox: stdout_lines: list[str] = [] def print_callback(_stream: Literal["stdout"], text: str) -> None: - stdout_lines.append(text) + # pragma: no cover - Monty invokes this from its own Rust-owned + # thread, which coverage cannot trace. The captured stdout is + # asserted by test_execute_simple_code. + stdout_lines.append(text) # pragma: no cover max_chars = self._config.analysis.max_output_chars diff --git a/tests/sandbox/test_sandbox_toc.py b/tests/sandbox/test_sandbox_toc.py index 9146603e..10ae264a 100644 --- a/tests/sandbox/test_sandbox_toc.py +++ b/tests/sandbox/test_sandbox_toc.py @@ -364,3 +364,57 @@ class TestItemsJsonlSurfacesNewFields: assert expected <= set(r) assert "position" not in r assert "tree_depth" not in r + + +@pytest.mark.asyncio +class TestVfsReadPaths: + """The synchronous VFS readers bridge back to the event loop; drive them + through a worker thread the way execute() does.""" + + async def test_content_txt_is_read_lazily_per_document(self, temp_db_path): + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.document_repository.create( + Document(content="the stored body", uri="test://body", title="Body") + ) + doc_id = doc.id + + sandbox = Sandbox(temp_db_path, AppConfig(), AnalysisContext()) + + content = await _read_vfs_text(sandbox, f"/documents/{doc_id}/content.txt") + + assert content == "the stored body" + + async def test_document_files_are_read_only(self, temp_db_path): + async with HaikuRAG(temp_db_path, create=True) as client: + doc = await client.document_repository.create( + Document(content="x", uri="test://ro", title="RO") + ) + doc_id = doc.id + + sandbox = Sandbox(temp_db_path, AppConfig(), AnalysisContext()) + vfs = await sandbox._build_vfs() + sandbox._loop = asyncio.get_running_loop() + + with pytest.raises(PermissionError, match="read-only"): + await asyncio.to_thread( + vfs.path_write_text, + PurePosixPath(f"/documents/{doc_id}/content.txt"), + "nope", + ) + + async def test_toc_skips_gaps_in_item_positions(self, temp_db_path): + """Positions need not be contiguous — a heading's span may cover + positions that carry no item.""" + async with HaikuRAG(temp_db_path, create=True) as client: + doc_id = await _empty_doc(client, uri="test://gaps", title="Gaps") + # Positions 1 and 2 are absent between the header and the paragraph. + items = [ + _header(doc_id, 0, 1, "Intro"), + _para(doc_id, 3), + ] + await client.document_item_repository.create_items(doc_id, items) + + sandbox = Sandbox(temp_db_path, AppConfig(), AnalysisContext()) + toc = await _read_toc(sandbox, doc_id) + + assert [n["title"] for n in toc["tree"]] == ["Intro"] diff --git a/tests/test_context.py b/tests/test_context.py index ec945327..98191bd1 100644 --- a/tests/test_context.py +++ b/tests/test_context.py @@ -1360,3 +1360,16 @@ class TestExpandWithItemsPictureBytes: e_low = by_chunk["c-low"] assert e_low.image_data == {"#/pictures/0": "LOWBYTES"} assert "HIGHBYTES" not in (e_low.image_data or {}).values() + + +class TestSpanInWindow: + def test_zero_width_span_is_inside_when_position_is_in_window(self): + from haiku.rag.context import _span_in_window + from haiku.rag.store.models.document_item import DocumentItem + + item = DocumentItem( + document_id="d1", position=0, self_ref="#/pictures/0", label="picture" + ) + # A picture occupies no characters, so containment is by position. + assert _span_in_window((10, 10, item), 0, 20) is True + assert _span_in_window((30, 30, item), 0, 20) is False diff --git a/tests/tools/test_search.py b/tests/tools/test_search.py index 3fedd61c..2cd8499e 100644 --- a/tests/tools/test_search.py +++ b/tests/tools/test_search.py @@ -214,3 +214,49 @@ def search_config(): from haiku.rag.config import Config return Config + + +class TestBuildBinaryPartsFromResults: + """Picture bytes are attached once per (document, self_ref) pair.""" + + def test_results_without_image_data_contribute_nothing(self): + from haiku.rag.tools.search import build_binary_parts_from_results + + results = [ + SearchResult(content="text only", score=0.5, chunk_id="c1", image_data=None) + ] + + assert build_binary_parts_from_results(results) == [] + + def test_duplicate_document_and_ref_is_attached_once(self): + import base64 + from io import BytesIO + + from PIL import Image as PILImage + + from haiku.rag.tools.search import build_binary_parts_from_results + + buf = BytesIO() + PILImage.new("RGB", (4, 4), "red").save(buf, format="PNG") + png = base64.b64encode(buf.getvalue()).decode() + shared = {"#/pictures/0": png} + results = [ + SearchResult( + content="a", + score=0.9, + chunk_id="c1", + document_id="doc-1", + image_data=shared, + ), + SearchResult( + content="b", + score=0.8, + chunk_id="c2", + document_id="doc-1", + image_data=shared, + ), + ] + + parts = build_binary_parts_from_results(results) + + assert len(parts) == 1 From f6acb65e954184980db05cfb89feeca05252ce1a Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Sun, 26 Jul 2026 20:11:02 +0300 Subject: [PATCH 08/16] Reach and enforce 100% coverage Cover the remaining paths in the client, context, downloads, title generation, document tools and store models, and add fail_under=100 so uncovered lines fail CI. Six lines that no test can reach get a pragma with its reason: the docling import guard, the nameless PDF attachment, the FS symlink OSError guard that resolve(strict=False) absorbs, the docling bbox and LanceDB document-id shape guards, the tag-retention branch vacuum makes unreachable, and Monty's Rust-thread print callback. Fix test_find_config_file_user_config, which wrote its config into the cwd it had chdir'd to, so the cwd branch answered first and the user-directory lookup it names was never exercised. --- CHANGELOG.md | 4 + haiku_rag_slim/haiku/rag/client/documents.py | 3 +- haiku_rag_slim/haiku/rag/client/downloads.py | 3 +- haiku_rag_slim/haiku/rag/store/engine.py | 4 +- .../haiku/rag/store/models/chunk.py | 3 +- pyproject.toml | 1 + ...cuments_schedules_vacuum_when_enabled.yaml | 42 ++++++ ...ng_a_source_applies_an_explicit_title.yaml | 82 ++++++++++++ ...marize_document_returns_model_summary.yaml | 82 ++++++++++++ tests/store/test_document_items.py | 32 +++++ tests/store/test_restore.py | 25 +++- tests/store/test_v0_50_0_migration.py | 17 +++ tests/test_chunk.py | 5 +- tests/test_client.py | 51 +++++++ tests/test_config.py | 41 ++++-- tests/test_context.py | 125 ++++++++++++++++++ tests/test_converters.py | 17 ++- tests/test_database_autocreate.py | 23 ++++ tests/test_doctor.py | 23 ++++ tests/test_download_models.py | 71 ++++++++++ tests/test_lancedb_connection.py | 33 +++++ tests/test_picture_in_context.py | 29 ++++ tests/test_processing.py | 53 ++++++++ tests/test_title_generation.py | 37 ++++++ tests/tools/test_document.py | 27 ++++ 25 files changed, 817 insertions(+), 16 deletions(-) create mode 100644 tests/cassettes/test_client/test_import_documents_schedules_vacuum_when_enabled.yaml create mode 100644 tests/cassettes/test_client/test_reingesting_a_source_applies_an_explicit_title.yaml create mode 100644 tests/cassettes/test_document_tools/TestSummarizeDocumentTool.test_summarize_document_returns_model_summary.yaml diff --git a/CHANGELOG.md b/CHANGELOG.md index cc59c816..64452693 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,10 @@ # Changelog ## [Unreleased] +### Changed + +- Test coverage is enforced at 100% via `fail_under` in `[tool.coverage.report]`. + ### Fixed - `Store.set_haiku_version` stamps the store's own config into a recreated settings row instead of the process-global `Config`. diff --git a/haiku_rag_slim/haiku/rag/client/documents.py b/haiku_rag_slim/haiku/rag/client/documents.py index 6dca344e..ee054970 100644 --- a/haiku_rag_slim/haiku/rag/client/documents.py +++ b/haiku_rag_slim/haiku/rag/client/documents.py @@ -570,7 +570,8 @@ def _extract_pdf_attachments( for i in range(attachment_count): att = pdf.get_attachment(i) name = att.get_name() - if not name: + if not name: # pragma: no cover - pypdfium2 cannot produce a + # nameless attachment, so no craftable PDF reaches this. continue data = bytes(att.get_data()) child_uri = f"{parent_uri}#attachment={quote(name, safe='')}" diff --git a/haiku_rag_slim/haiku/rag/client/downloads.py b/haiku_rag_slim/haiku/rag/client/downloads.py index c3f0afcf..3cd51755 100644 --- a/haiku_rag_slim/haiku/rag/client/downloads.py +++ b/haiku_rag_slim/haiku/rag/client/downloads.py @@ -38,7 +38,8 @@ async def download_models( yield DownloadProgress(model="docling", status="start") await asyncio.to_thread(download_models) yield DownloadProgress(model="docling", status="done") - except ImportError: + except ImportError: # pragma: no cover - docling is installed in the test + # environment, and get_package_versions depends on it. pass # HuggingFace tokenizer diff --git a/haiku_rag_slim/haiku/rag/store/engine.py b/haiku_rag_slim/haiku/rag/store/engine.py index cc177ad8..0c6443ed 100644 --- a/haiku_rag_slim/haiku/rag/store/engine.py +++ b/haiku_rag_slim/haiku/rag/store/engine.py @@ -606,7 +606,9 @@ class Store: for tag in tags.values() if tag["version"] in timestamps ] - if not tagged: + if not tagged: # pragma: no cover - a tag's version is never absent from + # list_versions: vacuum retains every version at or after the + # oldest tag, so a tagged version is never cleaned away. return retention # LanceDB version timestamps are naive datetimes in local time. diff --git a/haiku_rag_slim/haiku/rag/store/models/chunk.py b/haiku_rag_slim/haiku/rag/store/models/chunk.py index b20d2972..8eacf3fc 100644 --- a/haiku_rag_slim/haiku/rag/store/models/chunk.py +++ b/haiku_rag_slim/haiku/rag/store/models/chunk.py @@ -74,7 +74,8 @@ class ChunkMetadata(BaseModel): continue for prov_item in prov: bbox = getattr(prov_item, "bbox", None) - if bbox is None: + if bbox is None: # pragma: no cover - docling's ProvenanceItem + # always carries a bbox; guards against a shape change. continue bounding_boxes.append( BoundingBox( diff --git a/pyproject.toml b/pyproject.toml index 245077e9..c077737d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -146,6 +146,7 @@ omit = [ [tool.coverage.report] show_missing = true +fail_under = 100 exclude_also = [ "if TYPE_CHECKING:", "@abstractmethod", diff --git a/tests/cassettes/test_client/test_import_documents_schedules_vacuum_when_enabled.yaml b/tests/cassettes/test_client/test_import_documents_schedules_vacuum_when_enabled.yaml new file mode 100644 index 00000000..aa8617e4 --- /dev/null +++ b/tests/cassettes/test_client/test_import_documents_schedules_vacuum_when_enabled.yaml @@ -0,0 +1,42 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '90' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - Batch imported body. + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: hEtFuRaGDb0C8ta6nvnwvKoBCbq9yOI8w0kFPcIyobwTOQU8W/YHvSBy4LwJ1Bw9K/X9OI49P71Ikt086IxBvaHWZDwPayq98/xhPLgQIrom1Zy886qQPBXV9Dyj3i29jtpCvZ05eryAhcK8oKw0vTp5mjoevCQ9MMoqvC0fgL0CDdm8UQ00vbZVcTuOj4K8WDYxOyE9Z7zE2Js6MSunPD8SSTzjHdW8suslujSFHrslhBI8+bnGuZg70ztfxgi9eQa5vN42i7zZXy07UlFRPPunl7z8h628/7cEPOwafbxjJUW8XE9+un52Lb2+9Yw82DqfOz1WVLxIfLi73iyVvCvxtbvEap680552vHJXubzJxE08QZjAOz52LD10KXw8Q+EvPHXWJTyskRY8v0r1vARwMLu6BZQ87P8DvIvWGjx52go9gh3ju/vTj7st7Ao8qZ27PI4/ULw1Hse8BwqxPBGyH70FM667naO0O6cRwLyJf3S8niA+PVgZwroTnTk8wW5rPD9ZbbxuwM+7Q/kDPO7XKry0Ia87Myatu0s6i7t58CU9Fj27vEChp7zRumM7UlcSO9M5vDuTypO8IUiDO9fmwLuLG8A73gWJu/YfbjylGQi82J8mPC93Bz2AwQo9dlJgtxuSBTxlvSG6ZBwbvPrNP7xLmks8H/1MPIo+0ryhMSw8zIqVPAUfBbxP98q77ZGDPC9ZcTy2T8+8xtVXPGSzGrxd4by8CISaPDu8Xbz67yQ8v1Lpu7X3LjzDK6w8d83muxgwnjzYK328ZXtnvA9xZLuEgBc8AY6dPI2MfrzT8T68L9YBu9ZPdrvy6wo9ikLhOlINBz2Y6lm7iRTku9PHG7zk8wk7WayJu1GOkTzO0Vs7X7nAOqbIIrxQj0I83HGDuzW5SzohODm6YwZUvFVd6rv744i8n3QCvfld5zsMsMi73396OwDUZ7xpjbg84FPwu2DgHD1JNT+9WXH3uxR1Pjx7poE8GCOmvOb7pzxed4k76gt1PLM1x7uJyNM8qQvIu7PxAzypGmK7KfQXvL5Tfbz6ldE8yg2tvCvxszvYlfS5RoJTvLRVqjva35m7YI1kO3zuh7xfmVo54mZru/nyDzwVCU68AwVyO1paADz/qrG8b/lvveJPejv9Ky88lmjivPB6Bbzz79I8k3FnPfKMFriWRrc7+8gRvHyIJ7uQMdS8w132O+UFbDzQacm7N2pEPID9EbpG6Mo8UrgFPZd1iruljDs6NvZbPCZGZTyNEuQ6Uuj0POHPErvcG1u9kJJrPCeIJLws0zS8AwRbO3o1ezufhMW86xKRu6/Dtbso/ow3y8SAvO1PgLsjnfS559+yO5w3gLv8D6S8g19vvC1EGrzL5TQ8ETTbvH9L8rwtClW7WropPC4gqzvrNSc6uMa0PB21QrzieTG8goviuoEh1buY75E7b2iKOyelirx9r+M72IvOu1mBT7xptn+8mAktO+Va5DvXGOo8wlKYO4E/a7xo7MU7MG4DvewoWzuE9p4776ElPUvbkDxhasC7GYNWO0iZrzuoKBo9JfhEOg4etzxj9tO8vLEdvCP+vrxCUgA85DNyu55X8rwbmHa8jlziO2L/sLqCRRK7TE0dPLD/1DpVF5E7lx+2vMhI6TxZcJC8rFDvPEZlKLkANI+8Byo6O6+o3DvI/tW77I8tPEEAh7zf0ao6jGfauymvpbwc3mE8yQuhPI+5nrxTR9y7cSzZvCE48TtQ9UA8Bqb+PBqvdb2v9dA8mW1wvfkWujzxlIq7G4Lku8CYkbvUscy7Q4ceu+mgjzwJQRo7xSQ8vM0JgrrY+Qa8gYA8PJnDzzzPSbE7LKA2vBD5ED3fuR48LLfHu/2Pcjwuqam6++anvN7TG70Yphe8usYKPTAq7zxW9ce8yBRxO4/p1bssTU+8gDzHOq/q47qHrIW7MT9Yu9ssIb0Q13G3g3TDO2te3zy0xpi6ZF+TvOGv9jwpiAa8BGOIO0fnvDxDIDm8GctIPD13mDxJ9Gu6/xKXOjawDDyxypI8X9/GvKVRrrxreLA8OHNCO4NxdLyVgcK8o93HPCZsBr0NkUQ8JzOEPCfU3LzR1SK8va83PM3azbv2nPU8w5d4O4CjjDxbM8A8rLSZvKr0pjwcV8080q9DPK4Gczz0w5i5QcF1u+I3LTvDguM85VMjPEJMnTxk0X48t18TvY5/6DtorBu7autYvTResztmrV481dKCvIHMgLy0do08LXJlu/gUyLxZimk7cUi/Or00erx4pGs8IWUmPa1ZAD0fT4M8nip9PB+GBjw063m8vNBcvEpbkzxVxF68n7qxPNMbTroHa948XSXUu+9IbLxsJf87D3EyOQi3LTzjSyc9HW57vSEQirzDdUg8K+LNPI64pDwWRPq8klBEvZkhEDyki2g8PRG5uxOyxTyBZKm6HsQXPOHVHb0/qWe8ykewvCpzcb1T1eo74NDzvBQ7Ybw2VbC7hEZvu0XMBbyNsc48hiAFPWCb7Ly8Qlo84FvQO2zPP7xhjr06mvi7u4HvvDtHzU48B/JpuuuVMLzrRD08TidgPWRGz7uVd9s8cpQdPNww6rvG1CI9TodTPWRKLjzc87M6rrP/vEOlEzyoLRk7ql0yvHHc2bwklhq8sOp5vAp/3DwpbzC9TONOvGBdJ7wz6ry7Jt4tOeiYRbyTfm08xOkUvLkEhLoTYjO7AIuMu7CO47sOt4G8gDfFOhwV67si3JE6sqF9vWMjr7vq+aW8YxdzPDXIwLw6qQQ8AlJKPCLLN72HHQ49o+DXPHVlo7tkbD084lTfO2Wn7zxKsNq7f48aPFSVzDtmY6S78n8vPGUEv7ruR026biMUvQ0VhbyED8C8wKu+PO5gzTt9mwI90XuEPL/4uDyt6S07X+7bubhrw7xpS1+8CFw8vL2L6zzy7Ra9d9asu9QQ9DxqoiC7gv7JO4RM77s0Mji8T/lcPLL1jDwf8LM8ZWpoPPKT6TyDV7m7Sce7O3wDgzzBCEs81FUSPWnNsLyN0Ye8wxZtPEhwULsbB7k8zsuMNqJ7HT1Ojss8IMu0vJCsDTyAVNw8cjUBOggllDw8pZA81+kOvCMcwLqZxlk8mId6PN3YajnJROo7nRfcvKAjhDxKYKq8ArGNO2ADVby/vae8RKYKPBOwcDo6weE83fpBPKA7C7yA2gs9YkcdvX7GETsuCvc7YEQKPI7BvDt78e67DIEAvB96u7zn73s7ZYdlPG+9HztlQ5+8EYd+PLqBMTzZRpo8HJOTuzTydDufdcu6c2LoOoak5LvcsmS8AcU5u+8qcDx8lXy80vqxvH2NwzvpiQW8U9SNOzDfCr3ofpc8uuRgvEjnLr3JYum8fNedvC/SjTyKsF08o9ahvDVS/jyDRB29rR9fvTM9LjzXLDQ8aZIrPMAsZDyMLRg8DyRAPeiy7zzLrGk9GArvuytXQL00ScW7/I2RvGrTfTzr4UC86ciDvEpPjLuwJpS85nBDPITEhbz4qgc8/sF9OxT+0TwMqU27oklsvOuH0LyHY/g8HsEGPRqO5LxXOCw8PunnvFAeLr29F3+8rIkdO/a6ZLzyoLM8UFm4PPTrLbxfiRo8tG+ivFelBzxJF2c732WQvGDmqjwtKza7WaRKPNl0/LnGF6s7fZVBvTKiJj3cFdM6Kbr2O47ShjzXoSg8kGCYOmKRlzwC3hk82ux5PBs8Lz1kkuq76vhZPBKx6bzZ9o27wda2vNXm5rzK3eo81ID6O6iiZbzCUQa8O7gxvAx+MzxgaQ+7PyppujBYDLun2dc8KQiRvF23sjs4Cmi8TFVyu3oKS7xZgES902LvuuMvbTtWr5I6tPyWPGCPpjpcPLw6czU3PYf2Mbxna/+6+hhovCXrgjwMmIK8RdXcPBw6wDxpvoI8cxzQPO9Iqzw5RgW9SqHGvFUVGbx9C6A7Uv7vPGilGrt0yzo89dgEu8j6RbxcALI8mwyEu+dyEL2XMvu8UhDGvKT/C7xPNd06ksQZPC40x7xnQe888RUwvf6hP71shzE7Ba+7vBI6szy80Ke8sA7Wu95G9bsAVM68DUdEvCWEDbykdLq8VDe4PHdImDwteFU7LBpRPGVHujxtrIm8ABakPLGW2TzpibI8Xmv7ubfOFLyL7zM8Lgq5O2MbDD1JNWE8EZrLu+VoH72RMje6RYRhvDYq9rtrTRY82bzevI8ICr21u348DKbfu4saZbwOFI27aXV8OFgbmzz9mwO9Y6bpu5j43Dszb0W8C46CvE/Ts7uHIIa8FIi8uyKhxLygUn6866PVPAFZZDyL9zg8uiC2vBK9rTvWP/M8wURMPQXk7bx6hjG7yL8OO7lPBr2O4fC8Dp7CPFIhIryxkOc70g+OPNpkAblBDNu8LDMYPWjlC72vq/I8E5pcPBdi0jxPGjG7BMIJO6VGCT3e39C7CmTWuwjCuzzQKte7Uft1uzRTp7xBIpK8bx6QvR2t47tmlIC8J2EKPAMMtbsvEaU7ivELvAGyRzzTkhE8oEgyvBWQZjz0jMk75hZKvEjDwTyGoxs9eiBMPOSztjs3QNK8N+itPOU/s7sBqEq9yyT7u9IIkDyHAtw8+z60vFrnu7zAaDM8cJhyPMh6zzssqa271lzAvFY8qTwQHsa819O/POb8kTq7F2C82iGSPFzDm7wJYLU8jzM/vPobBbvMm4S8SiclvC7u+zvPV4c7Mjr3PGtaFT3Q+pM85LJrPBZ5Q7xLfe46UX0hvKoZSzuvlR68PsJKPC90NTxTbt48Vuh6PHNPoDt6tBG8JAGEvC9sAD2H3mG8VqB+vKqiSz2ecxu7WSe7vOf5UT0LKf+5p+0PPH3hQz3cdfG8r7y6vMAu1DtlTDW8X3n4uv69ejuWF8e8GqNPPHdzgLyaIzQ9nysavUXUEb2yD8g8UQ16PJ2jC73EJjg8ccYLO7ITtLw5Hiy9qkOfvEdFIbxiEv+7siBBPHJYr7xQiYO7YzqpuZa4nLwX5Ig8od2EPIdQ7Tv9ty47G/GQO8qZH7zUBbK8S92evMc5Sj1Omik81ibVu0cg1ryAGoc81Lm3O5ggybsNu9o8zuqEPCFg1Lyomkk84vJnPFDkOTyh42o8Z87eu3NrI7tX16C7ev0gvfkkqjxJFxy8qIm3PCYFujvMqVa8dltUPAwDPTtAPkQ8dlE1vDDOtjzHUP07ZYAzusG41DtkMZe8KUH3O32KpDyZPQY8hFJvPOtcizucjvu8X0dbPPHimrsMiYW8oU6TvJo9dLv2dIW8gQ/vu0Dq6jxiVRG9UuCFvFZWnjwd2gE6PECyOo5l7ryYfYY8DYJ0vDDr8Tjb1T89VErkPFaPBL0q8WG7zHUsO58Ld7udfAe9d7jTvEkTFD23Yd+7Y3n4PGEWVrzLCxS90vXdvGHICbz18KC8ZvrItkkgvzwiIYE7+2f0POFAKbyxRo28yNN8PAdVQbshr9w8kjS7u914Xbz/iJK7AEyrudDTbjxp0wa7lECcPO6niTvJlNG8/fH4OgT9bLydeBs8EtouvYYxkDuo4Uw8g2PrvENXp7x96qe8IT6su6l0H7wvsvc7g8OVPFCraTzAfkg8cwH3uxxIHDvW6fm8BL0KPPFHDjn/sOW8B6arPFaeS7xW0pQ8Hm3XuqnbkbrWIys95vtUPY/tErzI6Q66MnaPuhh8m7x0Pfi8U1evvJKfCjuvamI8imxQO9QYBTymYgy9+9LbPD7d9TySaKw74nQZPWwIVLobLtM59fx5vFj7Bbw2nha9SWD+vPtTxjoKgrq8p1EEvVqxmjy9BgO9K/ioPPfwH7zQ7i88/tMAPYCmgzzQEH+7U8X3O+5gQTxkiJs8UH26u9ZtxTvxW3u9jxK8vP1ZqDzmjsI7gBmovOUiNjwactc8eykfuwE7n7xfLX+71QImPY7zwbuwFSE9oVo4vLDQ5zou38C8UCxbPNHakzzmdpG8B1PnuysTUDns2K28Tt+pvL2XGrwB32478BDgOsE0gTwEsVi7ZrJbvMxEzzpXiIK8QUTHPFh5wDyXWSS9Ak1EPHqDlLoAvzS9SCe3u6Vl/DyTYNY8ZWj1O91HmDypgga8xuZpvLupezqVAAK8f+SsvHqLhzvvUi09y2aUu6rRIrwxmhG8SIuLO601a7uO3UY8aF2DvOiooLsX6zA8DgoSPadTwDpD+bc6ns0NvJ2eNzyHfiM6f9i5u1o95LqgvZu8sSZTvEd+trxs7kA7bmnlukQaobw7CmO8n4rMu4n7wbzIkpw8B+Xuup1odTxZOHw8MqmePMgrHb0V1Ac9Fc7TvMZm37x3xKu6QtkjO9RwTLzrppC7lZibPOazGTx4luc8LlW9PBcwpjxJX+Y8+GFRPEmPJruB3SW9tcE+uZMzkLy0yJs8aKCtu3VVoLw1W3K8MCxavLXxIbzC1dy7N/FjOv+DM7xw14C7p3WMuqoQiDylx1a8gzAIPeJMNbx1roO8Hi+AvLK08Lr+Ywy9mxEOvWzLLjwKrnG8xR4JPHy3jDz5vVu8dElrvHKxsjwvnsY7vGArvPAI3bxxIMU8crQMPX0PYzy3S2Q8Nuc4PDpyyTy8vEs8dtHlOxo1A72DGYo8q/dtvIiGTL3g2F47tFssPMsoQTykvmI8sz+UPBAgR7znwTo9vNMpPAa+Nzz2UCU8ZK8IvCGhx7zNMvO81aaJPCVmM7xgAia7n8byPOa9/buWnAw9jCX+PPCzXTv7QgI9wC+uvGyNVTwhXAi8ErnvvDpnIDy60kO6KpJ3PN23mby2T1c8qVXmPIMEILw1zkU9Kiu9vBIgNj2xZ7C7In2evAUKczkJtvm8K53svG4IO7x1GwW9e6yqPKM8hTvslwy8SQgAu1o6DTtB0Gy8S9knPCJBl7z1VB69FUZLO+vW0rwrZCu98QPmPOqsy7yJBjw8hN3JPARmlbxNaXc8NCY0vNpgHDyx6r08Pv/SPN4uCL1GSg+9PFQxvduA5zxTSiI7qGoxPCNoQjpXaKg8XQclvdFL4DpBHN06VHMIu91uCLwTduO8H8k9vU46LDzewNG8oeOZvCO4WDsH/RC9MD6NvPSsaTyep5e6kipHPW/r07p9tH88cDEdvFEPITwJ1KQ8A0oaPHex9LdjBFm8FZojvFLu6zyvwZc8UsItPfR3KbumZxS8IJp5vEeUgrx7EA88DquzOzWLOTzOgpK8P1bsu6ePiDwp2nu7OeA8PM179LsS8A69gW+sPEGSsTxqh5U7KY9vurRhkTwglrS7gcCwPM12TTumSEq8CWZMvH4J07s9gA88Gz78OwZnyDy+kv+7qCRnuwbEtztfYGQ8b/2xPLNYc7tqwZK8ZPBFPS8DHjsIsJG8KHsVvVu+g7yGMTe9rdXlPEbjnrtHY/U8UuSsu9jRTj2DJ+E6qzsavYN9QjxhMNA4Ab0iu1ITEzy6bC88oR4ovX5GirvIVga8VXGHOmUgTjzAm5e8O7dWO4M80Tx/gxI51dG6O2sXRL2Fv2q8w68avbVIK73Thum8C2LkuwtXczudxaC8GVxcPGiagDpqtRi8vPMlPKvfkLo42Aa93lbOu2xnorxmOsk822EzPMwMtDy3JPK8uHwRPBZBfLyL0qM7i6abvBbXOD0/5yY85hJZvHBtfLoAydo7GLaQvEA2DTtNSKK8LK8YvH+tp7yfBHw8tgyVPPk6Oj0QpvS7M4i4vIugtbw4KzA8r+GTvJprAL20n5y8cCYuO+grrLvUGBu8TkqRO7mwo7t8pdc6K7+GPLRd0btuDpK7JacWPQVGMLz52HC8eTMhPNCzVjuoCMo8a4TLO2AwGr0zcqi7rUEGPSBh07wTmR69kofPvNBDdbwWqe+8kEsGvUZt4zsR8T87NCv7O5OPzzyCxsA8l31pPCAoO7ymTRW8jqU8uUcY8bwud887K50uu7psFDz/UBK8Q+LCvJmwlLzkWfm81bFzuu95Sjkq00E7KiSAPKoT7Dzz3lM8/SMSPWNEBrywejm73wApO1tnEzzkU/i69NIIve3OVrkZSR08ckVjPE1DfrwNnNw5OV4KvPDi0LqrK488CWaPvIbPCzwQNZa8ykCoPFc/ljxmYI48G26bPLULKrxlqnU8v8v+vGMFTjuFKKu856MwO7FvlzxGAWg8DlbrPAHS27x0hLi67nqmPBCJSruMNq08LxUdvHaF2jogct888JiWu7kZpTsiSy27Phnlu2ZCsjvq8Ne8lJU3PMEs1Twpk8U88CC/u0N3mDzp8O88pfCCu5w5pjukqCw8mfJCvIakVj16KtY8Ia8IvArn5DzADSu8etmkvFmZjTwB2hq81aMWux5imrwrZvK7OwDBOfHXAD0xTOQ2h5rLvMM9xzyNFUe8aeWxvHjMjzxkaYG5J4abPEk7RbpihNw8dRaEO78POD174wo8xUJDu0iCaDw17hE8LVEqPDpTAz0/DP27M0z1u0iT0TzHtci8z3kFuXGmizuJlxk9s5S8POJySDsVqSM8djzHvPN24jxNu0080hLUPLJJ0rqmpwA6Pdohu2q2dzx/7kG7S4EyPWnh3rzwuCm88t6ePD84ljyJ/O67E2t8u1AC0jzkvZW7K9CgvGA0urx5G828HDRZPDHkkLut1L+88yPMPFXK1jsFTSm9gv33O/5tsTx4bqM6r0eJPEIvrLvaWBo817oivCWk1LrqG0o8TzqGvF3m37sAmcy7m74MPUJepjwKLgC9GrKZOjpXa7yxv8i7/8/iu1KkIDzoMOI86n5/u7QqBz1H7h+7qOq2vHjZFry/ji+9d+fqvLUnr7zbYea8Nn5bPKrgnjyIw8y6hRn4uyuJHr09sN67D/CNvN1qQb2HwhE8vd0ePNfPEbwWwa47yUy+vO9wjDxcPc67eqVvPJfimzzsYyq9JEORPND86LmPAhm8cVN8PLz1ED290kA9seEGvGp/njx0Q3a7xlwwvAV0FL07rN47ryysPHnKbrw4eDM7WA+GvOmB7Lxmt6M8Mcl9PAyOS7ybLO+7/n1HOh8L7ztluFs8c0YrvFV3vTxEGXo8255EPBfrpTyjcx692ptUPIY+QTxSoIw78CfXOm5xnLz8RwS9XgDXPIpXRzuCoKY8uL3Huv6AozwGQ4C9Y7qivEnEg7y/sYo4l51ovLTNBTzy29W8Q/VXuktD5TvOiBg8vAihOlEW/bviTLe8RhdFOixjhzw6G8C7yIuovE3Qs7xIg6w8P8I8PGwVCLt8LCs9Q8TluYNmODzhhEw81v+5PLxAAD31KR683/mhPAb/nDzMWuu8CqwVPO0sCTwe7IS80IHDPO+CwbtYAm28M9s2vIA0nzuVbzq7TdLBvCcdyzwlies8Jza9u7V/1rxuBxO8BaKSvNABbLx2JNg7qBAiPFC2a7tpJrk7oK9KOVXFlbsWGLu31QubuxKkbzzWThA9RQKyvLpUojwtLhS8Dh4UPc50jbzQ1iQ8H53DO1nGdTq9tD88GkjvPCzLEDyB9YO8t4j9ujFaMTzZdUe8s44EvKx84buBLh69nvemvPK0rDsBAWK8kuMNPVtgvjskbge8ixX+PKoQZ7z0tte7So/SPE9i+zxHcpK8NVXJOjlOED16f/W7jHhNO/5paju4Bx68440uvURo6LwKugw8E0kcvezxczwMlsI7e2AQPGQjVbz22nm6O+yHvFdRvzzRfJM8SC1HPO3yCzzlBvG8bVI0PStka7y3aB47LNceO+jHlTuivc+8c2IAvQN/6rzdB5o8lxl7O8m9CL2+jqo8+6qyPKMakrxn0zS5oZiwuwPzIz1sGkK9wK+bO3rQ4DouH0u9kiCBvHhUXbwmaC27UzRrvN/eqzz2Ji68QFC/u70A3zw8xyA83yfUvBAOGj0oRjW86QMBvWkiYTxxu488l8iKPEyusDxvlAA8F2psvNFWXLwhnU087CXQuhUva7zqB+O7ooTjvAdC3bv9l7A8DfKCPCzYFT2UBB67H/s8vBLYsDuJjFK6OwU3vdCazLwsGx+9Ef62O0NA4TsJeHS78GjSPKb5rjzfH9U7GzLXOoumY7yDx6Y80pz0PD9n67rkOKm8tYLUOfNynTx1/1083lMBvdAfxjw3UJ+8q6btuxTrBLyJOHM70Dp2PIfH4rxoKdA8pH1CuvV4bDzlEYg8zhXCPFTEMbkx9fS7yBSWvGhTLjzDbSE8HmmIO1I12by6CCM6sgKtvOC8tTxe15o7Hl+SPEFBMTyCg708yf5IPBiksDzezLa8SP+HPfC9s7zcEMS8VbL5PI4ldDw6wps86FTmvNV+gjyW0gE8bfWoPMCIA7pgHLk8TibFu0qOsDxIR4e87oNcOtadBL1ll2o8rs6yO8iQ4zwZvau8i4IDPauT97vJn647bJuKPBlbzrtZtuA8Zc5aO2bVETn8vqe8NxgEuzskDDxmDdU6s5G/u7E0rbsOpsK8uv7NO2wPoDxs5Nq7q1ClvPJ+ULxyfXy8xlUsuyg+C7x1Kv856dQhvUR277tL2fy8r+ZdO57m4bvRXre8mX8NPVnZCr3bMgi8YQuWvPPzIL2tVkE8YrX8PM0ieTrMsa68FlkPvfMutrzM9kS8282yO3CiqDspETM8cviSun3ZebtSzcA7qmDzuttwnrukn0S8TZbxPNSzw7xznaE7u6fFvHlulTqRP1s86QLhO8BP5jzAfRE9ss1WvK9QsDxO0RO8+RRuPNdzpTyNxh+7vF/2O/34PLxpRu08MMaSvIXmibvb7uG8tA5eu0VA5LpxBBM8NoI5N6GtzrscJs+8lHc7PCfimjuCx468kM8lu+JH0rwW0IY3wEpBPTT/7Ly4h4A7cckju7h7/roOwuG8nBIIvWJHTzsxtT28mXLQPLTn4LyUUDY92AR3vOfNmjsHj6m8KHQ3POz0ET1W5FE8ImZrPOkPZLzZhIi8d563PDyaszktu4C8xtqmupIypTx+nIO8O3zvPLPTRTyzZA28pqI9vOkiRbxa1V+8gasWu/SMsjyR78o7u+EfPNrUYDx8+w06E9K2ulA2/jtJESW8/J51vICJyjw/s5w8O2nqO6V2oTlH9jY8/F8MPNqbJrz10ay8b98FPYc877wNauK8DsmPvTcRGLw4G4C8ewknurFS/Tt2z7S85RX0O+T6ZLyKbeo6vNHUunB15jsZrZo74qOHu7b2Br1mO0Y8ZGDDO5siwDw1bFk788W5O3oPJz3/bG+8MNGFO/y/0rzyrWc8VaxgvK4KJDzXhnC8RcckPKDdwrqTjGU6GlH3O8+wPL2DEfI7maGRO+XRTDwjfNW8pFu+u1pSsTy4R6E8OLyzvMgJIDxSt0U8T4aFvPZHDzyZYbm7hjI8vYEH6bwVDas8/bzgPPNW0bwkdCY86Lczu6ZzhDx7ffa86ii3vNagqrwYlfC7uz1AvFHShrt23gS9SOWnOzKJbjxoHDC8sa2rvPbX9rp99sy8lcn/PCxeojyYX188LM4DPBMoaDxF5wm8C8chPFAjMjwOnYO8K7yBOy956bxNcBk7QfBFOjPYg7ySngq8lUDuOwG0zLsHJYW8tpeMPGrlqDsLw3c8Mh30OnOwkDd60pm8ifomvbZj4rwZd1U8tb7MOpY1k7s0crQ8YvykPLlWxDqFuh88YZ21vAZB8LwGL7M8BXxjvNMhZzoLAFg7b29sPA7jRrx97Lu8S0ITvFBkvbve0Hw8V02DvPPhPj3xsDO87WK2PDI9rzsP7js8g1H0vFCRO7wyEz48dSYJPTA6trw9a9y8oW2SvEn8yLxJd5A888hUvMNbubzWZwY9OR2ePDI4GLsd28G84VVMPPk7gzwgg5a7l4i5PAdwTbt48/g7/l5CPOTAKTw4E1093p1SPPiJnDpIkzY814sgvOhfULwtNgk9eiGlOo9wnruCcOK8m5Q0PUCtzjzzxba51LtbPN+wPL3N8aw75532PP7sFr1Ufsk8m22NPCZdP7tcRAe7KCEcvMKhgDyrDEK8pcTTvBL+4LxHrxG8wqeGPAmxLL3QnOk7BZkevc/ZHL3vpg07b4QGPJ8A/7unCCY8ywDLvMP2Arwtues70S6Du+rztzwtiU67b95yPDAjd7yXnHM6htIGvPVrwDzbwYy7WIgKOw+fijyisdi8GkZ/vLODTrxlnty8OfWLvIosNLuUBXW7qDVyPJUkeTz5nhS9s70Tux0nyjwwgWC8uaM4PADxhrxF1fG7jcWZvEY6G7wyKS29t+2XvNOhH7zgqhi8P5CvucOjBr0cCRI9kohKPGQOIj13xaO70FazPN8LoDzRJRc8N/GNO39NE7xosgW9dKcmvPO8tDw7x1K9pe3+O9tMMTs2CBa9lM27vFrfJL03i2A9ysCivLAj2Dveo+G7YsFAPJhRh7xKuxE71Hkqu8PBqDxdMa08xKKsvMq0rruaOJY8o2wXuuldpTymfPS8In7+vKikHD1TC/w8QhyDu1usJLz5+yq8apo2O2rNt7sgiow86VQIPEbrCj0NEp676C2KOk41ITw7vvK76gFCvEIvs7p1SNM8Oo4CvIcScr2CcVe7tqOzvB04j7zi7s28DAW5POZXQTxgPBC8s4eRvJa/hLzs2AG9kSzdvCNIkDwA+IM7IROxvDOetTz+7hm8RtSdOgj8Qz1Tukg96PUoO4zY0LsgVoI6PRcnPEgTl7ye6M68t6UmPCYy9busHwG8iLItvEkU37tZICu8LVDKO0HQhbunFbs69x06PHN1irwhNYW7zZvCPGSkl7zur169l0H1vGB6vTwthrq88FE3vByMWjv+Mf48jTfOu9nXizyoqDo7ONa4u3sKV7vT2Zi8cqkSO+orEL1adXM83m/iu7nTtjzr3RM8YDiHOsQ7oLp62y684BmVvABzmbx5UKU7pzqpvMik8zvVSOs8uEl9vC9PHrykdOq7VdxcvK3bTz18b4M8eCSYu66M6Lypwqe8nXW9u3yeJLyFRYQ8sCWevDsY4byE4gu9w5i8O5f7F72r+Lo6NGwLu1aZVjv1ob88ahGmvchyMjzaSUC8KkRyPASm/rxBRo08yAOVO9+KODvzeUq8BLKKvHTqkjwouBa9xNydPIo7ELy4ZsU84GZbvMwXgjyuFw+8a4u1u7MnFLsfQZU8JnMiuyo5SLsb9xY8CLoRu4QAjjpe7YO8p1YOvJdHG7yRrw28KnWLOwLi5rvKFeA81IJ5vB95fzw5e+E7U2lBO3O8sjwKA548mhenvBc8vTyf9sM8NfWivCz5/zxcKKe7EfWhuk6ZYLtJWq47Zn4dPCd2KzuIgBk8XJAoveggCL24grC8Y+juO8HNmDyK5ok7WAQyvLklrTyBUBs8tKRIPJOmgTtpeAi878M0uytrgbvo8/Q6mg2FOyNHKTtsWYa8ux0nPb+mZDwCrBI8zMUTvNy0DDwQwPU8HwzQPEjvFj3AN8M7P8ChvLteDTz6FuU75c59O8eFwrzel0q7RV3VvI0E8ryoswY8e6kkvCxDsbx0sR+87xrWvDezy7yTTSG9dOIUvfBnerxJAMM6TlfNO+bp5LwOUMG7RtuFPEusVzs5kSa8MnMyPKzEjLuYMjE8xrQavQIAl7xc02U7zJSzOz/fkLvq5DU8XrgzPKdOl7yGsa68Va8NPCT1nTwIgBW9drjdvL0kMjzpF4u7ovdfvEf0cjzvPi47BG3ovI8Etrycnz686RYKPA== + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 5 + total_tokens: 5 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_client/test_reingesting_a_source_applies_an_explicit_title.yaml b/tests/cassettes/test_client/test_reingesting_a_source_applies_an_explicit_title.yaml new file mode 100644 index 00000000..f352df06 --- /dev/null +++ b/tests/cassettes/test_client/test_reingesting_a_source_applies_an_explicit_title.yaml @@ -0,0 +1,82 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '84' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - stable content + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 3 + total_tokens: 3 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '85' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - changed content + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 3 + total_tokens: 3 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_document_tools/TestSummarizeDocumentTool.test_summarize_document_returns_model_summary.yaml b/tests/cassettes/test_document_tools/TestSummarizeDocumentTool.test_summarize_document_returns_model_summary.yaml new file mode 100644 index 00000000..6e46a3e6 --- /dev/null +++ b/tests/cassettes/test_document_tools/TestSummarizeDocumentTool.test_summarize_document_returns_model_summary.yaml @@ -0,0 +1,82 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '142' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - Python is a programming language. It is widely used for web development. + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 15 + total_tokens: 15 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '134' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - JavaScript runs in the browser. It powers interactive web pages. + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 13 + total_tokens: 13 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/store/test_document_items.py b/tests/store/test_document_items.py index ba99178a..e6b1ed6c 100644 --- a/tests/store/test_document_items.py +++ b/tests/store/test_document_items.py @@ -1003,3 +1003,35 @@ async def test_replace_for_document_with_no_items_deletes_existing(temp_db_path) await repo.replace_for_document("doc-1", []) assert await repo.get_all_items("doc-1") == [] + + +class TestExtractItemTextFallbacks: + def test_table_returns_none_when_serialization_fails(self): + """A serializer that raises leaves the table with no extractable text + rather than aborting the extraction pass.""" + doc = _doc_with_tables(1) + + class _Boom: + def serialize(self, item): + raise RuntimeError("serializer exploded") + + assert extract_item_text(doc.tables[0], doc, get_serializer=_Boom) is None + + def test_file_backed_picture_has_no_inline_bytes(self): + """A picture whose ImageRef points at a file rather than a data: URI + carries nothing to decode.""" + from docling_core.types.doc.document import ImageRef + + from haiku.rag.store.models.document_item import _decode_picture_bytes + + doc, pic = _doc_with_captioned_picture("caption") + pic.image = ImageRef.model_validate( + { + "mimetype": "image/png", + "dpi": 72, + "size": {"width": 1, "height": 1}, + "uri": "file:///tmp/picture.png", + } + ) + + assert _decode_picture_bytes(pic) is None diff --git a/tests/store/test_restore.py b/tests/store/test_restore.py index 5202bb97..ab1460b9 100644 --- a/tests/store/test_restore.py +++ b/tests/store/test_restore.py @@ -112,8 +112,10 @@ async def test_restore_safety_tag_name_collision(temp_db_path, monkeypatch): await store.create_tag("release-1") await store.create_tag("before-restore-20260715T143012Z") + await store.create_tag("before-restore-20260715T143012Z-2") + safety_tag = await store.restore_tag("release-1") - assert safety_tag == "before-restore-20260715T143012Z-2" + assert safety_tag == "before-restore-20260715T143012Z-3" @pytest.mark.asyncio @@ -406,3 +408,24 @@ async def test_wait_protected_returns_result_on_same_tick_cancellation(): result, cancelled = await outer assert result == "done" assert cancelled is True + + +@pytest.mark.asyncio +async def test_wait_protected_reraises_when_recovery_itself_is_cancelled(): + """If the recovery coroutine ends cancelled there is nothing to wait for, + so the cancellation propagates instead of looping forever.""" + import asyncio + + from haiku.rag.store.engine import _wait_protected + + async def self_cancelling_recovery() -> str: + current = asyncio.current_task() + assert current is not None + current.cancel() + await asyncio.sleep(0) + return "unreachable" + + outer = asyncio.create_task(_wait_protected(self_cancelling_recovery())) + + with pytest.raises(asyncio.CancelledError): + await outer diff --git a/tests/store/test_v0_50_0_migration.py b/tests/store/test_v0_50_0_migration.py index f53904d6..7f2553fd 100644 --- a/tests/store/test_v0_50_0_migration.py +++ b/tests/store/test_v0_50_0_migration.py @@ -126,6 +126,19 @@ class TestV0_50_0Migration: } ), ), + # Matches the LIKE on the quoted-key form, but only nested — + # there is no top-level key to rename. + LegacyDocumentRecord( + id="nested-only", + content="x", + uri="u3", + metadata=json.dumps( + { + "raw_headers": {"etag": "abc"}, + "source_revision": "v3", + } + ), + ), ], ) @@ -141,6 +154,10 @@ class TestV0_50_0Migration: "my_etag_key": "v", "source_revision": "v2", } + assert by_id["nested-only"] == { + "raw_headers": {"etag": "abc"}, + "source_revision": "v3", + } async def test_unparseable_metadata_skipped_without_crashing(self, temp_db_path): """A row with malformed JSON in `metadata` must not abort the whole diff --git a/tests/test_chunk.py b/tests/test_chunk.py index 68c1222d..288371e8 100644 --- a/tests/test_chunk.py +++ b/tests/test_chunk.py @@ -482,6 +482,9 @@ async def test_chunk_repository_get_by_id_and_list_all_pagination(temp_db_path): assert len(first) == 1 assert first[0].id == everything[0].id + # offset is applied even when it selects the whole set + assert len(await client.chunk_repository.list_all(offset=0)) == len(everything) + if len(everything) > 1: second = await client.chunk_repository.list_all(limit=1, offset=1) assert len(second) == 1 @@ -526,4 +529,4 @@ async def test_process_search_results_rejects_unknown_score_column(temp_db_path) return pd.DataFrame([{"id": "c1", "content": "x", "metadata": "{}"}]) with pytest.raises(ValueError, match="Unknown search result format"): - await client.chunk_repository._process_search_results(_Frame()) # ty: ignore[invalid-argument-type] + await client.chunk_repository._process_search_results(_Frame()) diff --git a/tests/test_client.py b/tests/test_client.py index fe545765..7a94b1fa 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -2518,3 +2518,54 @@ async def test_visualize_chunk_falls_back_when_expansion_drops_refs(temp_db_path images = await client.visualize_chunk(stored[0]) assert len(images) == 1 + + +@pytest.mark.vcr() +async def test_import_documents_schedules_vacuum_when_enabled(temp_db_path): + """A batch import with auto_vacuum on queues a background vacuum.""" + from haiku.rag.config import AppConfig + + config = AppConfig() + config.storage.auto_vacuum = True + + async with HaikuRAG(temp_db_path, config=config, create=True) as client: + docling_doc = await client.convert("Batch imported body.") + chunks = await client.chunk(docling_doc) + await client.import_documents( + [ + DocumentImport( + docling_document=docling_doc, + chunks=chunks, + uri="test://batch-vacuum", + ) + ] + ) + + assert client._vacuum_tasks + + +@pytest.mark.vcr() +async def test_reingesting_a_source_applies_an_explicit_title(temp_db_path): + """Re-adding an unchanged source with a new title updates just the title.""" + async with HaikuRAG(temp_db_path, create=True) as client: + with tempfile.TemporaryDirectory() as temp_dir: + source = Path(temp_dir) / "retitled.txt" + source.write_text("stable content") + + first = await client.create_document_from_source(source) + assert not isinstance(first, list) + source.write_text("changed content") + + second = await client.create_document_from_source( + source, title="Explicit Title" + ) + + assert not isinstance(second, list) + assert second.id == first.id + assert second.title == "Explicit Title" + + +async def test_update_document_rejects_unknown_id(temp_db_path): + async with HaikuRAG(temp_db_path, create=True) as client: + with pytest.raises(ValueError, match="not found"): + await client.update_document("no-such-document", content="x") diff --git a/tests/test_config.py b/tests/test_config.py index ba659d29..c848beb4 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -42,17 +42,17 @@ def test_find_config_file_cwd(tmp_path, monkeypatch): def test_find_config_file_user_config(tmp_path, monkeypatch): """Test finding config in user config directory.""" monkeypatch.delenv("HAIKU_RAG_CONFIG_PATH", raising=False) - monkeypatch.chdir(tmp_path) - # Mock get_default_data_dir to return tmp_path - def mock_get_default_data_dir(): - return tmp_path + # The data dir must differ from the cwd, or the cwd branch answers first + # and this never reaches the user-directory lookup. + cwd = tmp_path / "cwd" + cwd.mkdir() + data_dir = tmp_path / "data" + data_dir.mkdir() + monkeypatch.chdir(cwd) + monkeypatch.setattr("haiku.rag.utils.get_default_data_dir", lambda: data_dir) - monkeypatch.setattr( - "haiku.rag.utils.get_default_data_dir", mock_get_default_data_dir - ) - - config_file = tmp_path / "haiku.rag.yaml" + config_file = data_dir / "haiku.rag.yaml" config_file.write_text("environment: production") found = find_config_file() @@ -518,3 +518,26 @@ def test_expand_env_var_plain_string_unchanged(tmp_path): config = load_yaml_config(config_file) assert config["environment"] == "production" + + +def test_find_config_file_returns_none_when_nothing_exists(tmp_path, monkeypatch): + """No env var, no file in cwd, none in the data dir.""" + monkeypatch.delenv("HAIKU_RAG_CONFIG_PATH", raising=False) + monkeypatch.chdir(tmp_path) + + empty_data_dir = tmp_path / "data" + empty_data_dir.mkdir() + monkeypatch.setattr("haiku.rag.utils.get_default_data_dir", lambda: empty_data_dir) + + assert find_config_file() is None + + +def test_load_default_config_falls_back_to_builtin_defaults(monkeypatch): + """With no config file discoverable, the packaged defaults are used.""" + from haiku.rag.config import _load_default_config + + monkeypatch.setattr("haiku.rag.config.find_config_file", lambda _=None: None) + + config = _load_default_config() + + assert config.environment == AppConfig().environment diff --git a/tests/test_context.py b/tests/test_context.py index 98191bd1..dd5f1cc8 100644 --- a/tests/test_context.py +++ b/tests/test_context.py @@ -1373,3 +1373,128 @@ class TestSpanInWindow: # A picture occupies no characters, so containment is by position. assert _span_in_window((10, 10, item), 0, 20) is True assert _span_in_window((30, 30, item), 0, 20) is False + + +@pytest.mark.asyncio +class TestExpandWithItemsWindowEdges: + async def test_empty_window_returns_original_results( + self, temp_db_path, monkeypatch + ): + """Refs resolve but the surrounding window comes back empty, so there is + nothing to expand from.""" + from haiku.rag.client import HaikuRAG + from haiku.rag.store.models.document import Document + + async with HaikuRAG(temp_db_path, create=True) as rag: + doc = await rag.document_repository.create( + Document(content="body", uri="test://window") + ) + assert doc.id is not None + await rag.document_item_repository.create_items( + doc.id, + [ + DocumentItem( + document_id=doc.id, + position=0, + self_ref="#/texts/0", + label="paragraph", + text="body", + page_numbers=[1], + ) + ], + ) + + async def no_window(*_args, **_kwargs): + return [] + + monkeypatch.setattr( + rag.document_item_repository, "get_items_in_range", no_window + ) + + result = SearchResult( + content="original", + score=0.9, + document_id=doc.id, + doc_item_refs=["#/texts/0"], + ) + expanded = await expand_with_items( + rag.document_item_repository, doc.id, [result], 5000 + ) + + assert [r.content for r in expanded] == ["original"] + + async def test_result_with_unmatched_refs_passes_through(self, temp_db_path): + """Two results share a document; the one whose refs resolve is expanded + and the other is returned unchanged.""" + from haiku.rag.client import HaikuRAG + from haiku.rag.store.models.document import Document + + async with HaikuRAG(temp_db_path, create=True) as rag: + doc = await rag.document_repository.create( + Document(content="body", uri="test://mixed") + ) + assert doc.id is not None + await rag.document_item_repository.create_items( + doc.id, + [ + DocumentItem( + document_id=doc.id, + position=i, + self_ref=f"#/texts/{i}", + label="paragraph", + text=f"paragraph {i}", + page_numbers=[1], + ) + for i in range(2) + ], + ) + + resolvable = SearchResult( + content="paragraph 0", + score=0.9, + document_id=doc.id, + doc_item_refs=["#/texts/0"], + ) + unmatched = SearchResult( + content="untouched", + score=0.5, + document_id=doc.id, + doc_item_refs=["#/texts/404"], + ) + + expanded = await expand_with_items( + rag.document_item_repository, doc.id, [resolvable, unmatched], 5000 + ) + + assert "untouched" in [r.content for r in expanded] + + +def test_build_result_skips_positions_with_no_item(): + """A sparse position map (items removed or never stored) leaves gaps in the + range; those positions contribute nothing.""" + from haiku.rag.context import _build_result + + original = SearchResult(content="p0", score=0.9, document_id="d1") + # Positions 1 and 2 in the 0..3 range carry no item. + pos_to_item = { + 0: DocumentItem( + document_id="d1", + position=0, + self_ref="#/texts/0", + label="paragraph", + text="first", + page_numbers=[1], + ), + 3: DocumentItem( + document_id="d1", + position=3, + self_ref="#/texts/3", + label="paragraph", + text="last", + page_numbers=[1], + ), + } + + built = _build_result(0, 3, [original], pos_to_item, False, 5000) + + assert built.content == "first\n\nlast" diff --git a/tests/test_converters.py b/tests/test_converters.py index 9d686227..e6579281 100644 --- a/tests/test_converters.py +++ b/tests/test_converters.py @@ -1672,7 +1672,7 @@ class TestDoclingServeZipParsing: @pytest.mark.asyncio async def test_convert_text_plain_builds_document_locally(self, converter): """format="plain" never reaches the network.""" - converter.client.submit_and_poll_zip = AsyncMock( # ty: ignore[invalid-assignment] + converter.client.submit_and_poll_zip = AsyncMock( side_effect=AssertionError("must not call docling-serve") ) @@ -1680,3 +1680,18 @@ class TestDoclingServeZipParsing: assert isinstance(doc, DoclingDocument) assert "just text" in doc.export_to_markdown() + + +@pytest.mark.asyncio +async def test_docling_serve_convert_file_wraps_text_read_failure(tmp_path): + """An undecodable text file surfaces as a ValueError naming the path.""" + config = AppConfig() + config.processing.converter = "docling-serve" + converter = get_converter(config) + assert isinstance(converter, DoclingServeConverter) + + source = tmp_path / "broken.txt" + source.write_bytes(b"\xff\xfe\x00\x01 not utf-8") + + with pytest.raises(ValueError, match="Failed to read text file"): + await converter.convert_file(source) diff --git a/tests/test_database_autocreate.py b/tests/test_database_autocreate.py index d15bb950..f7a0b63f 100644 --- a/tests/test_database_autocreate.py +++ b/tests/test_database_autocreate.py @@ -43,3 +43,26 @@ async def test_operations_work_after_database_created(tmp_path): doc = await client.get_document_by_id(docs[0].id) assert doc is not None assert doc.content == "Test content" + + +@pytest.mark.asyncio +async def test_default_db_path_comes_from_storage_data_dir(tmp_path): + """Omitting db_path places the database under the configured data dir.""" + from haiku.rag.client import HaikuRAG + from haiku.rag.config import AppConfig + + config = AppConfig() + config.storage.data_dir = tmp_path + + client = HaikuRAG(config=config) + + assert client._db_path == tmp_path / "haiku.rag.lancedb" + + +@pytest.mark.asyncio +async def test_vacuum_is_callable_on_the_client(temp_db_path): + """The public vacuum() delegates to the store.""" + from haiku.rag.client import HaikuRAG + + async with HaikuRAG(temp_db_path, create=True) as client: + await client.vacuum() diff --git a/tests/test_doctor.py b/tests/test_doctor.py index d6d0d3a2..03771327 100644 --- a/tests/test_doctor.py +++ b/tests/test_doctor.py @@ -1206,3 +1206,26 @@ async def test_duplicate_documents_check_reads_config(temp_db_path): ).severity is Severity.WARN ) + + +@pytest.mark.asyncio +async def test_many_unembedded_chunks_are_sampled(temp_db_path): + """Beyond the sample limit the detail list ends with a count of the rest.""" + db = await _build_db(temp_db_path) + chunks_tbl = await db.open_table("chunks") + await chunks_tbl.add( + [ + ChunkRecord( + id=f"z{i}", + document_id="d1", + content="x", + metadata=json.dumps({"doc_item_refs": ["#/texts/0"]}), + vector=[0.0] * VECTOR_DIM, + ) + for i in range(8) + ] + ) + report = await run_doctor(_config(), temp_db_path, {}) + details = _result(report, "unembedded_chunks").details + assert len(details) == 6 + assert details[-1] == "... (+3 more)" diff --git a/tests/test_download_models.py b/tests/test_download_models.py index 50ad06a4..41e571c5 100644 --- a/tests/test_download_models.py +++ b/tests/test_download_models.py @@ -6,6 +6,7 @@ import pytest from haiku.rag.client.downloads import download_models from haiku.rag.config import Config +from haiku.rag.config.models import ModelConfig @pytest.fixture @@ -108,3 +109,73 @@ async def test_download_models_no_ollama_models(mock_to_thread): models = {e.model for e in events} assert "qwen3-embedding:4b" not in models assert "gpt-oss" not in models + + +@pytest.mark.parametrize( + "configure,expected_model", + [ + ( + lambda c: setattr( + c.reranking, + "model", + ModelConfig(provider="ollama", name="rerank-model"), + ), + "rerank-model", + ), + ( + lambda c: ( + setattr(c.processing, "pictures", "description"), + setattr( + c.processing.conversion_options.picture_description.model, + "provider", + "ollama", + ), + setattr( + c.processing.conversion_options.picture_description.model, + "name", + "vision-model", + ), + ), + "vision-model", + ), + ( + lambda c: ( + setattr(c.processing, "auto_title", True), + setattr(c.processing.title_model, "provider", "ollama"), + setattr(c.processing.title_model, "name", "title-model"), + ), + "title-model", + ), + ], + ids=["reranker", "picture_description", "auto_title"], +) +async def test_ollama_models_from_every_config_slot_are_pulled( + mock_to_thread, configure, expected_model +): + """Each config slot that can name an ollama model contributes to the pull set.""" + from haiku.rag.config import AppConfig + + config = AppConfig() + configure(config) + + @asynccontextmanager + async def mock_stream(method, url, **kwargs): + mock_resp = AsyncMock() + + async def aiter_lines(): + yield '{"status": "success"}' + + mock_resp.aiter_lines = aiter_lines + yield mock_resp + + with patch( + "haiku.rag.client.downloads.httpx.AsyncClient", + return_value=_mock_httpx_client(mock_stream), + ): + pulled = { + progress.model + async for progress in download_models(config) + if progress.status == "pulling" + } + + assert expected_model in pulled diff --git a/tests/test_lancedb_connection.py b/tests/test_lancedb_connection.py index 23abae0e..c601a2c5 100644 --- a/tests/test_lancedb_connection.py +++ b/tests/test_lancedb_connection.py @@ -355,3 +355,36 @@ class TestVectorIndexCreation: indexes = await store.chunks_table.list_indices() assert not any("vector" in idx.columns for idx in indexes) + + +class TestStoreMiscellany: + @pytest.mark.asyncio + async def test_create_makes_missing_parent_directories(self, tmp_path): + nested = tmp_path / "a" / "b" / "db.lancedb" + + async with Store(nested, create=True) as store: + assert store._is_new_db is True + + assert nested.exists() + + @pytest.mark.asyncio + async def test_stored_vector_dim_is_none_for_corrupt_settings(self, temp_db_path): + async with Store(temp_db_path, create=True) as store: + await store.settings_table.update( + {"settings": "not json at all"}, where="id = 'settings'" + ) + + assert await store._get_stored_vector_dim() is None + + @pytest.mark.asyncio + async def test_vacuum_skips_when_already_running(self, temp_db_path): + async with Store(temp_db_path, create=True) as store: + async with store._vacuum_lock: + # Returns immediately rather than blocking on the held lock. + await store.vacuum() + + @pytest.mark.asyncio + async def test_history_rejects_unknown_table(self, temp_db_path): + async with Store(temp_db_path, create=True) as store: + with pytest.raises(ValueError, match="Unknown table"): + await store.list_table_versions("not_a_table") diff --git a/tests/test_picture_in_context.py b/tests/test_picture_in_context.py index 770c7f57..55f2f368 100644 --- a/tests/test_picture_in_context.py +++ b/tests/test_picture_in_context.py @@ -1011,3 +1011,32 @@ async def test_rag_capability_attaches_images_for_vision_model(temp_db_path): assert isinstance(result, ToolReturn) assert result.content is not None assert any(isinstance(part, BinaryContent) for part in result.content) + + +def test_build_picture_chunks_records_provenance_pages(): + """A picture with provenance contributes its page numbers to the chunk.""" + from docling_core.types.doc.base import BoundingBox + from docling_core.types.doc.document import ProvenanceItem + + from haiku.rag.client.processing import build_picture_chunks + from tests.store.test_document_items import _docling_doc_with_picture + + doc = _docling_doc_with_picture() + picture = doc.pictures[0] + picture.prov = [ + ProvenanceItem( + page_no=3, + bbox=BoundingBox(l=0, t=10, r=10, b=0), + charspan=(0, 0), + ), + # A repeat of the same page must not be counted twice. + ProvenanceItem( + page_no=3, + bbox=BoundingBox(l=0, t=20, r=10, b=10), + charspan=(0, 0), + ), + ] + + chunks = build_picture_chunks(doc, document_id="doc-1") + + assert chunks[0].metadata["page_numbers"] == [3] diff --git a/tests/test_processing.py b/tests/test_processing.py index 65c1ca86..d3ce970a 100644 --- a/tests/test_processing.py +++ b/tests/test_processing.py @@ -211,3 +211,56 @@ def test_merge_picture_chunks_no_pictures_returns_text_chunks(): assert result is text_chunks assert [c.order for c in result] == [0, 1] + + +@pytest.mark.asyncio +async def test_convert_dispatches_large_pdfs_through_split_and_merge( + tmp_path, monkeypatch +): + """With split_pages configured, PDF conversion routes through the + split-and-merge helper rather than the converter directly.""" + from docling_core.types.doc.document import DoclingDocument + + config = AppConfig() + config.processing.split_pages = 2 + + pdf = tmp_path / "big.pdf" + pdf.write_bytes(b"%PDF-1.4 stub") + called: dict = {} + + async def fake_split(converter, path, uri, slice_size): + called["slice_size"] = slice_size + called["path"] = path + return DoclingDocument(name="merged") + + monkeypatch.setattr( + "haiku.rag.converters.pdf_split.convert_pdf_with_splitting", fake_split + ) + + doc = await convert(config, pdf) + + assert doc.name == "merged" + assert called["slice_size"] == 2 + assert called["path"] == pdf + + +@pytest.mark.asyncio +@pytest.mark.parametrize( + "make_source,match", + [ + (lambda d: (d / "missing.md").as_uri(), "File does not exist"), + (lambda d: _write_unsupported(d), "Unsupported file extension"), + ], + ids=["missing_file", "unsupported_extension"], +) +async def test_convert_rejects_bad_file_uris(tmp_path, make_source, match): + from haiku.rag.client.exceptions import UnsupportedSourceError + + with pytest.raises(UnsupportedSourceError, match=match): + await convert(AppConfig(), make_source(tmp_path)) + + +def _write_unsupported(directory): + target = directory / "thing.sqlite3" + target.write_bytes(b"binary") + return target.as_uri() diff --git a/tests/test_title_generation.py b/tests/test_title_generation.py index c13f736b..a88802c5 100644 --- a/tests/test_title_generation.py +++ b/tests/test_title_generation.py @@ -371,3 +371,40 @@ class TestRebuildTitleOnly: # Only the second doc should have been processed assert len(processed_ids) == 1 + + +@pytest.mark.asyncio +async def test_generate_title_with_llm_returns_model_output(monkeypatch): + """The agent's output is stripped and returned.""" + from pydantic_ai.messages import ModelMessage, ModelResponse, TextPart + from pydantic_ai.models.function import AgentInfo, FunctionModel + + from haiku.rag.client.titles import generate_title_with_llm + from haiku.rag.config import AppConfig + + def respond(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse: + return ModelResponse(parts=[TextPart(" A Generated Title ")]) + + monkeypatch.setattr( + "haiku.rag.utils.get_model", lambda *a, **kw: FunctionModel(respond) + ) + + assert await generate_title_with_llm(AppConfig(), "body") == "A Generated Title" + + +@pytest.mark.asyncio +async def test_generate_title_with_llm_returns_none_for_blank_output(monkeypatch): + from pydantic_ai.messages import ModelMessage, ModelResponse, TextPart + from pydantic_ai.models.function import AgentInfo, FunctionModel + + from haiku.rag.client.titles import generate_title_with_llm + from haiku.rag.config import AppConfig + + def respond(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse: + return ModelResponse(parts=[TextPart(" ")]) + + monkeypatch.setattr( + "haiku.rag.utils.get_model", lambda *a, **kw: FunctionModel(respond) + ) + + assert await generate_title_with_llm(AppConfig(), "body") is None diff --git a/tests/tools/test_document.py b/tests/tools/test_document.py index 432dc86b..ab935cf4 100644 --- a/tests/tools/test_document.py +++ b/tests/tools/test_document.py @@ -187,6 +187,33 @@ class TestSummarizeDocumentTool: assert "Document not found" in result + @pytest.mark.vcr() + @pytest.mark.asyncio + async def test_summarize_document_returns_model_summary( + self, doc_client, doc_config, monkeypatch + ): + """A resolvable document is summarised and labelled with its title.""" + from pydantic_ai.messages import ModelMessage, ModelResponse, TextPart + from pydantic_ai.models.function import AgentInfo, FunctionModel + + def respond(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse: + return ModelResponse(parts=[TextPart("A concise summary.")]) + + monkeypatch.setattr( + "haiku.rag.tools.document.get_model", + lambda *a, **kw: FunctionModel(respond), + ) + + docs = await doc_client.list_documents() + assert docs and docs[0].uri + + toolset = create_document_toolset(doc_config) + summarize_tool = toolset.tools["summarize_document"] + result = await summarize_tool.function(make_ctx(doc_client), docs[0].uri) + + assert "A concise summary." in result + assert "Summary of" in result + @pytest.fixture async def doc_client(temp_db_path): From 7ba78fdde3db814699e423cff53dfe2e6048529b Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Sun, 26 Jul 2026 20:18:19 +0300 Subject: [PATCH 09/16] Normalize pragma comments to the codebase's single-line form --- haiku_rag_slim/haiku/rag/client/documents.py | 3 +-- haiku_rag_slim/haiku/rag/client/downloads.py | 3 +-- haiku_rag_slim/haiku/rag/ingester/sources/fs.py | 4 +--- haiku_rag_slim/haiku/rag/sandbox/sandbox.py | 12 +++++------- haiku_rag_slim/haiku/rag/store/engine.py | 4 +--- haiku_rag_slim/haiku/rag/store/models/chunk.py | 3 +-- tests/test_processing.py | 14 +++++++------- 7 files changed, 17 insertions(+), 26 deletions(-) diff --git a/haiku_rag_slim/haiku/rag/client/documents.py b/haiku_rag_slim/haiku/rag/client/documents.py index ee054970..4b0373e2 100644 --- a/haiku_rag_slim/haiku/rag/client/documents.py +++ b/haiku_rag_slim/haiku/rag/client/documents.py @@ -570,8 +570,7 @@ def _extract_pdf_attachments( for i in range(attachment_count): att = pdf.get_attachment(i) name = att.get_name() - if not name: # pragma: no cover - pypdfium2 cannot produce a - # nameless attachment, so no craftable PDF reaches this. + if not name: # pragma: no cover - pypdfium2 always names them continue data = bytes(att.get_data()) child_uri = f"{parent_uri}#attachment={quote(name, safe='')}" diff --git a/haiku_rag_slim/haiku/rag/client/downloads.py b/haiku_rag_slim/haiku/rag/client/downloads.py index 3cd51755..0aaf8771 100644 --- a/haiku_rag_slim/haiku/rag/client/downloads.py +++ b/haiku_rag_slim/haiku/rag/client/downloads.py @@ -38,8 +38,7 @@ async def download_models( yield DownloadProgress(model="docling", status="start") await asyncio.to_thread(download_models) yield DownloadProgress(model="docling", status="done") - except ImportError: # pragma: no cover - docling is installed in the test - # environment, and get_package_versions depends on it. + except ImportError: # pragma: no cover - docling installed in test env pass # HuggingFace tokenizer diff --git a/haiku_rag_slim/haiku/rag/ingester/sources/fs.py b/haiku_rag_slim/haiku/rag/ingester/sources/fs.py index 2e131401..26747ecd 100644 --- a/haiku_rag_slim/haiku/rag/ingester/sources/fs.py +++ b/haiku_rag_slim/haiku/rag/ingester/sources/fs.py @@ -143,9 +143,7 @@ class FSSource: if path.is_symlink(): try: resolved = path.resolve(strict=False) - except OSError: # pragma: no cover - strict=False absorbs - # symlink cycles and missing targets, so no real link - # reaches this; kept as a guard against platform drift. + except OSError: # pragma: no cover - strict=False absorbs these continue if not resolved.is_relative_to(self.root): continue diff --git a/haiku_rag_slim/haiku/rag/sandbox/sandbox.py b/haiku_rag_slim/haiku/rag/sandbox/sandbox.py index 07743508..76486690 100644 --- a/haiku_rag_slim/haiku/rag/sandbox/sandbox.py +++ b/haiku_rag_slim/haiku/rag/sandbox/sandbox.py @@ -356,8 +356,7 @@ class Sandbox: return read_toc for doc in docs: - if not doc.id: # pragma: no cover - rows read from LanceDB always - # carry an id; only a hand-built Document could be id-less. + if not doc.id: # pragma: no cover - stored rows always carry an id continue doc_id: str = doc.id doc_dir = f"/documents/{doc_id}" @@ -438,11 +437,10 @@ class Sandbox: stdout_lines: list[str] = [] - def print_callback(_stream: Literal["stdout"], text: str) -> None: - # pragma: no cover - Monty invokes this from its own Rust-owned - # thread, which coverage cannot trace. The captured stdout is - # asserted by test_execute_simple_code. - stdout_lines.append(text) # pragma: no cover + def print_callback( # pragma: no cover - runs on Monty's Rust thread + _stream: Literal["stdout"], text: str + ) -> None: + stdout_lines.append(text) max_chars = self._config.analysis.max_output_chars diff --git a/haiku_rag_slim/haiku/rag/store/engine.py b/haiku_rag_slim/haiku/rag/store/engine.py index 0c6443ed..50d4a73a 100644 --- a/haiku_rag_slim/haiku/rag/store/engine.py +++ b/haiku_rag_slim/haiku/rag/store/engine.py @@ -606,9 +606,7 @@ class Store: for tag in tags.values() if tag["version"] in timestamps ] - if not tagged: # pragma: no cover - a tag's version is never absent from - # list_versions: vacuum retains every version at or after the - # oldest tag, so a tagged version is never cleaned away. + if not tagged: # pragma: no cover - vacuum never cleans a tagged version return retention # LanceDB version timestamps are naive datetimes in local time. diff --git a/haiku_rag_slim/haiku/rag/store/models/chunk.py b/haiku_rag_slim/haiku/rag/store/models/chunk.py index 8eacf3fc..b2936e15 100644 --- a/haiku_rag_slim/haiku/rag/store/models/chunk.py +++ b/haiku_rag_slim/haiku/rag/store/models/chunk.py @@ -74,8 +74,7 @@ class ChunkMetadata(BaseModel): continue for prov_item in prov: bbox = getattr(prov_item, "bbox", None) - if bbox is None: # pragma: no cover - docling's ProvenanceItem - # always carries a bbox; guards against a shape change. + if bbox is None: # pragma: no cover - prov always carries a bbox continue bounding_boxes.append( BoundingBox( diff --git a/tests/test_processing.py b/tests/test_processing.py index d3ce970a..29ec8fdc 100644 --- a/tests/test_processing.py +++ b/tests/test_processing.py @@ -244,12 +244,18 @@ async def test_convert_dispatches_large_pdfs_through_split_and_merge( assert called["path"] == pdf +def _write_unsupported(directory): + target = directory / "thing.sqlite3" + target.write_bytes(b"binary") + return target.as_uri() + + @pytest.mark.asyncio @pytest.mark.parametrize( "make_source,match", [ (lambda d: (d / "missing.md").as_uri(), "File does not exist"), - (lambda d: _write_unsupported(d), "Unsupported file extension"), + (_write_unsupported, "Unsupported file extension"), ], ids=["missing_file", "unsupported_extension"], ) @@ -258,9 +264,3 @@ async def test_convert_rejects_bad_file_uris(tmp_path, make_source, match): with pytest.raises(UnsupportedSourceError, match=match): await convert(AppConfig(), make_source(tmp_path)) - - -def _write_unsupported(directory): - target = directory / "thing.sqlite3" - target.write_bytes(b"binary") - return target.as_uri() From f96a428ef1a6c3c34d8bf1d51cab2dfc28c4a254 Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Mon, 27 Jul 2026 10:44:32 +0300 Subject: [PATCH 10/16] Fix defects found reviewing the coverage work check_source_accessible narrowed its handler to ValueError, but Path.exists re-raises errno values outside its ignored set (EACCES, ENAMETOOLONG). Those were swallowed before and now escaped into the rebuild sweep the guard exists to protect. Catch OSError too. Restore the arity guard in _common_path_prefix: without it an empty list raises from min() and a single label yields a prefix covering the whole path. Two tests would have hung rather than failed on regression (the vacuum skip and the protected-wait cancellation); both are now bounded. The import vacuum test raced against the done-callback that discards the task, and now spies on the call instead, with a negative control. Replace assertions that could not fail: blank-query search against an empty corpus, a batch flush counted against an empty table, a picture description asserting its own input state, and an FS scheme check with nothing on disk to resolve. The get_model matrix asserted only the returned type across 26 cases and now pins the per-provider settings. The three batching tests now count flushes, which revealed embed-only writes through chunks_table.add rather than _flush_rebuild_batch. --- haiku_rag_slim/haiku/rag/client/documents.py | 8 +- haiku_rag_slim/haiku/rag/client/rebuild.py | 3 + haiku_rag_slim/haiku/rag/doctor.py | 2 + ...ory_get_by_id_and_list_all_pagination.yaml | 49 +++++- ..._search_returns_empty_for_blank_query.yaml | 82 ++++++++++ ...ts_schedules_vacuum_per_config[False].yaml | 42 ++++++ ...ts_schedules_vacuum_per_config[True].yaml} | 0 ...ild_batch_is_a_noop_without_documents.yaml | 42 ++++++ tests/ingester/test_fs_source.py | 5 + tests/ingester/test_webdav_source.py | 19 +-- tests/sandbox/test_sandbox_toc.py | 15 +- tests/store/test_restore.py | 4 +- tests/test_chunk.py | 29 ++-- tests/test_chunker.py | 7 +- tests/test_client.py | 38 +++-- tests/test_config.py | 2 +- tests/test_context.py | 8 +- tests/test_database_autocreate.py | 10 +- tests/test_embedder_config.py | 7 +- tests/test_lancedb_connection.py | 16 +- tests/test_rebuild.py | 85 ++++++++++- tests/test_utils.py | 142 ++++++++++++++---- 22 files changed, 518 insertions(+), 97 deletions(-) create mode 100644 tests/cassettes/test_chunk/test_chunk_search_returns_empty_for_blank_query.yaml create mode 100644 tests/cassettes/test_client/test_import_documents_schedules_vacuum_per_config[False].yaml rename tests/cassettes/test_client/{test_import_documents_schedules_vacuum_when_enabled.yaml => test_import_documents_schedules_vacuum_per_config[True].yaml} (100%) create mode 100644 tests/cassettes/test_rebuild/test_flush_rebuild_batch_is_a_noop_without_documents.yaml diff --git a/haiku_rag_slim/haiku/rag/client/documents.py b/haiku_rag_slim/haiku/rag/client/documents.py index 4b0373e2..a9698ce5 100644 --- a/haiku_rag_slim/haiku/rag/client/documents.py +++ b/haiku_rag_slim/haiku/rag/client/documents.py @@ -908,8 +908,10 @@ async def update_document( def check_source_accessible(uri: str) -> bool: """Check if a document's source URI is accessible. - A stored URI that no longer parses (``urlparse`` rejects malformed IPv6 - hosts) counts as inaccessible rather than aborting the caller's sweep. + Anything the URI itself makes unanswerable counts as inaccessible rather + than aborting the caller's sweep: ``urlparse`` rejects malformed IPv6 + hosts, and ``Path.exists`` re-raises errno values outside its ignored set + (an unreadable parent directory, an over-long name). """ try: parsed_url = urlparse(uri) @@ -918,5 +920,5 @@ def check_source_accessible(uri: str) -> bool: elif parsed_url.scheme in ("http", "https", "s3"): return True return False - except ValueError: + except (ValueError, OSError): return False diff --git a/haiku_rag_slim/haiku/rag/client/rebuild.py b/haiku_rag_slim/haiku/rag/client/rebuild.py index 0ff37cb5..6ba9ca7b 100644 --- a/haiku_rag_slim/haiku/rag/client/rebuild.py +++ b/haiku_rag_slim/haiku/rag/client/rebuild.py @@ -281,6 +281,9 @@ async def _populate_staging_table(client: "HaikuRAG") -> None: pagination drift), so peak memory stays bounded regardless of corpus size. The vector column is omitted — the point of embed-only rebuild is to regenerate it. + + Requires ``_resolve_rebuild_recovery`` to have cleared any leftover + staging table first: ``create_table`` raises if the name is already taken. """ db = client.store.db tables = (await db.list_tables()).tables diff --git a/haiku_rag_slim/haiku/rag/doctor.py b/haiku_rag_slim/haiku/rag/doctor.py index c885dc68..9355a26b 100644 --- a/haiku_rag_slim/haiku/rag/doctor.py +++ b/haiku_rag_slim/haiku/rag/doctor.py @@ -330,6 +330,8 @@ def _common_path_prefix(labels: list[str]) -> str: Returns "" unless the shared prefix is long enough to be worth factoring out of every line (deep URI trees are otherwise unreadable). """ + if len(labels) < 2: # pragma: no cover - families always have >=2 members + return "" lo, hi = min(labels), max(labels) end = 0 while end < len(lo) and lo[end] == hi[end]: diff --git a/tests/cassettes/test_chunk/test_chunk_repository_get_by_id_and_list_all_pagination.yaml b/tests/cassettes/test_chunk/test_chunk_repository_get_by_id_and_list_all_pagination.yaml index c4d2bfa1..2875e5ea 100644 --- a/tests/cassettes/test_chunk/test_chunk_repository_get_by_id_and_list_all_pagination.yaml +++ b/tests/cassettes/test_chunk/test_chunk_repository_get_by_id_and_list_all_pagination.yaml @@ -8,7 +8,7 @@ interactions: connection: - keep-alive content-length: - - '123' + - '4851' content-type: - application/json host: @@ -18,9 +18,32 @@ interactions: encoding_format: base64 input: - |- - First paragraph. - Second paragraph. - Third paragraph. + Jakarta Election Campaigns Heat Up: Here's How to Understand the System + As election day in Jakarta draws nearer, candidates are out in force using various strategies to woo voters and prepare to exercise their democratic rights. Citizens make their voices heard as the city vibrates with life. This coverage offers valuable insight into campaign activities while offering an in-depth guide for understanding electoral processes in Jakarta. + Initial Launch of Candidates' Campaign Plans on September 1 + After September 1st, when campaign season officially kicked off, candidates have moved swiftly to engage their bases. Amira Bintang, an upstart candidate with extensive social activism experience and promising urban development and public transportation reform as key platforms of her candidacy speech in Jakarta; incumbent Rizal Harahap relies heavily on his track record and highlights all infrastructure projects completed during his term. + Campaign Strategies: From Digital Battlegrounds to Door-toDoor Outreach + Campaign strategies have taken an advanced turn as candidates leverage digital media to reach a wider audience. Hashtags, viral videos, targeted ads and targeted messaging can all play an influential role in changing public opinion with just a tweet or meme. At the grassroots level candidates engage in door-to-door campaigns personalized for individual voters in an attempt to connect. + - |- + Bintang's interactive app for gathering real-time feedback from citizens about daily commute challenges was applauded as an innovative form of civic engagement, while Harahap launched a series of webinars featuring experts discussing economic growth under his administration. + Rallies and Persuasion + Jakartan politicians know the power of an impassioned speech cannot be underrated, and candidates have been taking full advantage of its effectiveness at rallies. Rallies feature vibrant colors, banners and impassioned discourse in an attempt to win converts over. At one high-spirited rally on October 22, Bintang outlined her policy plans for improving education and healthcare to an appreciative crowd while Harahap's rallies often consist of shows of solidarity from various political allies united behind his plea for continuity and stability. + Debates: Clashes Between Visions and Policies + - |- + Debates are one of the highlights of Jakarta election campaigns, allowing candidates to outline their platforms and discuss critical issues. On November 5th, citizens witnessed an exhilarating debate between candidates Bintang and Harahap over whether the city was prepared for digital transformation in public services; Bintang advocated an aggressive move toward smart city model while Harahap advocated a more measured approach so as not to alienate less tech-savvy residents. + Voter Engagement: Making Every Vote Count + Ensuring every eligible voter is engaged and informed remains an ongoing challenge for Jakartans. Civil society groups and independent bodies host workshops and publish voter guides to inform voters of their rights and choices, while an annual democracy festival such as that held on November 20 featured interactive exhibits on Jakarta's electoral history as well as mock voting booths for first-time voters. + Campaign Financing: Transparency and Accountability + - |- + Campaign financing has always been a contentious topic in elections, and this election cycle is no exception. Bintang's campaign, funded largely through crowdfunders online supporters, stands in stark contrast with Harahap's sophisticated machine backed by both private donors and party funds. To protect democratic decision making processes from any + undue influences on decision-making processes, Jakarta Election Commission mandated strict reporting and transparency measures during campaign financing decisions. + Before Election Day: Submit Final Appeals Now + As election day nears, candidates make their last appeals to voters. Bintang plans a visit through key neighborhoods while Harahap plans a final rally scheduled for late November. Both camps are honing their messaging and policy proposals while encouraging supporters to make an appearance at polling booths on November 8th. + Polling Day: The Final Act of Campaign Activities + On December 6th, voting booths across Jakarta will open their doors, signalling the culmination of weeks of intense campaigning. Voters will cast their vote and candidates await results that depend on how effective their strategies, speeches and outreach initiatives have been. + - Jakarta's vibrant election campaign offers an insight into its flourishing democracy. As the city looks ahead to an + exciting new chapter in its political history, electoral processes demonstrate the significance of people-power in + shaping our collective futures. model: qwen3-embedding:4b uri: http://localhost:11434/v1/embeddings response: @@ -31,14 +54,26 @@ interactions: - chunked parsed_body: data: - - embedding: 4UTKuJFfELs+/CI83lvAPGrSv7lhKTM9qn9kPToOxbsgQ5Q8AAwyvb2jN7ychW68amtRO6u6Zr2/hHs8iJDlvKidHL2hi6W8TAgjPV4tAruRCBK8YWkJvVUc77tU0i29pSuLPN1eiLxuwYW83AoFvfFt4Tw7Vcs6pnMCvAF8Db2ZA9M8zhzMOwYlFzua02O8TYUZupc3HrwT+VA7A1S1OkqqZDuv7WU6rLVUPLSFtzzrNMa8ZRQcPcTGXzwrHRE9cPe6vNAIrrhqRWg7QyLTufHFJL0cY8a8Z8WdO9S3qL2t0Do9nytEOldPGr0Y/I68o1iJO7SrCr2L5UE8yWTZvGjtpTaKOM+8REwDPWf4A7zVkaw8MPPFu6XIabynk9U8CVtxO4FdLjxBRZq8VBy8vFaCIrwt2dQ8kRnPPPwcxjtmroY8Myr7OjlrBbhX2lw8dUV/PDdoNzyRrpg8d8ncu9fHdbwn9Qc8URDjOxr/OL3oWIq8n0nFPK0wGLuxlJW8VS2Eu/BQrrzTXWm65jdcPBCOmjrjIfi7lQ+xPLwoC72tMVY7Q4SFvA50CDtBBaS7/98yvDa6djwwW1u8Ci8LvNFEubyksda80WMJPEVPhrwyP7o8AGzYPLzizzt6WXk70no9vEKTBT19VFA8nDexOk6WUDySWMY7eHdUvELJc7vn6z47XFu5PKA8fDzImre6EkGfvOGfQjwntwK94sxyO3MvSDvZefE7a03Ku9hTFTzd4Q48Qm+9O8goDzyuIi09RTwevJeTZ72waoS8YNXHujp3jTzC55O6BEHdOxzfVzzywjA7iJXIt4MzBLwyA0Q8QC/su4m5WzxFGpI8+4f6O9fEQbyWdY48pTnVO8X8QLzZrmo8ismgPPDjpbs8r2s7bor7vJidLzxjL488S5hzu7HfIb1a7X28U0zxvCPPHrwz/KW8J4GGu+5wkry8XD68ahVIu0T/rjw2SWI8oy6quekuO7wcb2c8vlrbu17imruGDZM8RtKmPHo6prxCtGw8ZJbYu8ERGDzaIse7n/EgvI4g97ykQw896FpFvMEYyDyvKW07zSFFvLnUSzyyPBG8dibcuz9oELtA/ug8sg0tvKUTbjy7WUi700zrO9NH5DwznIC8lk/PvDCzYDyeMYy79lzWvHF/qbzo9m08ZhxOPQoZWDxK9cY7pIvSum/yO7vbtv+8S5i/ux7FNrpkxvU4yegEPETjyLtcBNs8c0uFPPmdwLyzROe7ozuVPB2+OzvbTDs8yRhZu94eD7zcG7q7uiSIPEMcrLwQ4jO8tv5fPHT+3js5HYC8aTNSOuZt17uW2O28oL+hvNMgnzkEugC7ad4+PNL+Q7wzTVM7X8TOOzAgQ7zwsUc8RvHNO1BOqDzl6bW6l81avPDzcry42Ky7dRKYPBLMyjzw6wE9jQxYvIKrZjxh+a28GsooPeEPu7pUO4m8z8vQO8Jbdz1aN4S7bvkNu0ypPTyJXvE7/u20PFd2jLs6QaU8yj3CvEqo0js1Utm7/pejPHPc6bmSTwE8iEiZvFQBETxcs5481H0xvIyalzx7chE8btjvO77rxbvWiCo8eFnfvLAyi7xCwsE8m89rvB/h9DrCF5I7REwvPDu20bw++Uk7WUhoPBOFCDy+f349+J02vXKhl7xelkw8FOLDPFZ9WTyKs2Y74ufuvLcT0LvUwZc7TiOLvKSGv7ysZvo7qbZsvYviG72VgVq8TJ0kvIjHyzwoQY48RLGNPNRx1bx0jTE86Wd1vLquvzylPPu8v0wiusJwl7rgvXm8RkVVPKqqSD1KQxa8c6lEPEGH2Ly2mlM80KzBPA6rWLw09Ni8i08kvPpszLwWdpa8VLiIve00R7yM0dy8Thxguj+jE7wWZg88mnd7PHoXrTz3OqG8NXjUuwR7LT0kxvc8P0e1vG+yObx6hj67nQduPJ95ZLwudRm8l98wOryxkjyB04S86QL8vGcUETv/cds8Yb3DOxWBHLz6UF48uRs7vALv2zx6K6a81CV8unE/fDzh4h48Xr1ePCJfmLwrqgk9ZWM6vWWPFrxD7e04RR6iOpFuND2prB28vHwgvBhnmDpMxk47ugsWPEs2ljtbffc8ljQTPA56uTxorCI9A1CYvCTmnLx9y868E/SPvEDLnTxdwrC7LL99PITZ3bynDxg9ji/aO6qi1ju0u0u7MHqivKdtiTyFDlM8kqUuvWDL/TzLi747pro6vC9vnDzLTgQ8t1OevJ2qx7yjLLa84lqCvFD+IjwTi0k8AUunu+4WaLoFUdG8HCjuu2CqIDwhuYQ7IFT6u8GVCT3qR1K7Vw80PRoLWrulyt+7VLqouzcmq7zPAa485ts4vEwhxDsAWco8YdI/vTOvnTynepa8X2jEPLuj07zw7u+7lprnvMgfubxcvE28PkAYvGT7OrwJf7E8iv2AOuDZJb1+vxC9YpWgvCnx0b0ZK1A8jdoOvOcvLb0S78y8lu41O3/3srzFuQK8wx8IPQLXlDxwEwi9hQz4upzFJb1cow08eCcBvIinVDz9XKa7mT95unfPzTv+26I8USvRPAEASDwl/gQ9y89HuyrXXrykgpA8qCmFO30w8DzfKx091HB8O4gAbj0We788SM4YvDZKkbtW5RQ8jEkGOxIytjqUuAu8FPKWPJORNzxHC2K8cCtePOCnGL3Keum75nP9vN6RcrunXuc8OPg7PA2+GbxLBRU9Y9o2usmUVjyTh9C69l0uvUOgmDzJM5c8W1zgvGSfUbwDo1C8oz2oux2gvLybaog8SLOWuxejhrwki0y7Y/7/PIH6Tzsls927yPZ5vEsxPTwXxiE7I6CdPBhvUrxyCZs8RP6xvL4LiLshtIW8eN97PWgTzrsgzAw9uZJovC6IdjseNZk7zttmvJGKZrybVdM6m61AurSZATyJY9G8dJOLuzW4mzxoZqw8JDRQPfyoGbwXsHO6es2/POpwJTzORj+8i45avMy7nzo7JYA7bRuhudZx1zx6frM8P6W7u7/tSzyzC4A8Vsa0PHqUebzBBoa8rlfnu5/5izu2IFq7WfTCPDGDpbyLRLC8oBafvGA5UTxYV1a8kAC9vDKJ2jy4Rsg89Iy1PFsdIbxcN7k75oQDvUoV+rzZqMC8lVRDPa5tKrteUqO7elBFvBhOAjvhSYM8fni/PC9gpLyL3TE7FPudvHvzojpPZg48zJCtPJe/u7yo5IY8MXeePOh1RLxAqOE82fBYPE6TsjzyhQO8hYIOPKoLk7yN3Vo8BWgXvEFq1DzE/ts7Yve9O0vj5bxSi/68TALpvHiwHDy7Z5Q7bWciOqQ68Ts2dNK86I3kPO9DXb0Aju28W+MPvXXTqjxv9pu8ggsDvDOLGTzq6FY8CjVzu4g+jjyVANW8nthIvZ8dIz3u84S83+Mova2yVzyxYaU8vmnZPOHZ1rvRzU6852QaOj9IpTuJrha8ZSVtvFj3rjyaEIi85Cj/PHlhBDx6iJK6yAfEvFXjlLy+SJk7Y6fWt/hDAD05CNI8McSOvNOskLzAHIY8eYahO5Lj2bwGAoi6fFGhvM53YbzfzDc9MffMPEi5irwY3TI9Aq2jvPLnzzr66tY8BS95vFNfhTuG8w+8A2gxPFk41bw9ab26uMJmPKdBlzw0Rkq86Ta5PESG2zyBtao8IVkWPIycsbv5Efo8FfyYO0lXFjz7ZiE8nygKPZqaFj0rssQ78sQrvGkUprtXvUS9aFSfvO8z07yc2BC8YkVVPIKe4zz2soY84c8HvD3RzTx4h8I7DE8qvEAJzzz6E3G8RrsSvU9EPr2Iu308gPaVuyxwODx2moS8+YnJvIKbpTs+6uu86TTTvJ+k4btA5D69/AA4PPHpMzukazY8DKEbPEPXwrrng/o8i9pvPYLQTbxwW+27MpPtusosiTuGb7u8trW3PKmYNjzZb4E7LqhuvDKB1Tz2TbG83A5DOzYAYTyZnyc8TcuZvLg9aDxkR+m8jV1BOoHj3jwmyaM8ge+5PGgAAbwfl3c84q7fvB1qD7zI8jA8k8QJuksxvjwSYgc9VL6BO5bgyzv0aDW7+ZbHO/GjbryjP8C85vaPPIneUjzidN27BY7au5w8qTx6QYK8Avrbu+8yULkcdsG8D8gKPevH9jv0keq8+fY6vGEwSjufY6485/51um3esLw8MR09mOSSOzpZ97vRUsU8dzT/vG4KP7zlsRU8c+QzvAvi8Tx0soQ7vBItvFlfnry4gvQ8/zNNO+2k3bxSBfi5jm2JvCgCLb18SF08a6l6vL1X9zpL3p48B4mMO4lsqjwfY9s7Kl/JOwxiMzw1SRY6PupbPTKjczvw5xu9rxywuiVmorzkP1i8yy8RPYEKaDzDfiE9FttFvGN/bzzE0r28VWgrPCz+1LdMrsK8oGnSPEhIwjtPjJo8rP8FPVgrcjxDQZC8SwNIPCA27Tt7Rz68pfiMOwfJW7wYOzE7YKLyvExYJb1bc6W7IcfSO/UozbxsAfc8HWK1vJHVObw6f/Y8Ts1LPLn4qLxaF465jcjGPPWakzyLXhk9rzOQu6C2czx3z4A8ZIhPPKHCKT2ap8k8jz8uPEVKy7zhQHo82qJmuiJm1Dvj/Ri9MtAiPYK3JjzcCwg8kZANPEbIpzwzZqe8GSyJPD9Psjzo9Go86oXgvJDV8zsT6hI90uBeu4PUWTyIiFW8ukGcu6FNWDwXwI67EE1XPVM44Txt4wa9XcA/vAhJZ7tWokY8N3WsvAjcVDwL7BO8D2u9POzvvLwXpMg8R7PVO2djgbxFv7y8De6LvPkjkzvYpim9jYjYPIq+ijzB6Iw57CknPMKe3jzfjB872w7UuqwV3ryThDc80PU9vQV/fzztCdm8xLyyPD5TJTvsKxa9w0vZO2PUOLxnAoM8AnkTvZAC2rzIbiI9LWyUPILYeLzpxHi8aLT4PEHZubsUkTi7tUPEu2RKO70P0eC73OODPPcdlrd4/607WwiwvM7S5LyLOCc8a6c6O2daqrzcMfc8CuC/OwYA3rzz8Um7Z0eDvOBB7Ts1cvM8vDH5vM2jWz0Y9lY8q/lKvBTJFz0sMui88a59Owt96ztDg7W8q1viOzKKvbxnsKs8UuAvPL8mUzzfdFc7yZUwu0prG7sfFAK94x/cPLgOlzwd9cE8NAh7vB1CRbvzoXi8yXUyO3trN7zNQZE8tx8AvDFb9LsIl4e8act1PF24PD3hWjw9tq+TPKmZED1T6ve89/y/O/5fgrxeUli87rq4vDc1EL1M7to8GBibuSiE4juBlLe5lLU5PCoaFLwpTgI8gAb5u8bjjjs15Q08pUx3PLcj6Dr/Xe07qoDiPDqKC71NXG285smdPDQmxLxyuqc8Yr42vG/xZzzG0586nB4wPWDYZrx+sQW9mECRvEHEWjyEzFC3iriIvECDtDl0mhE8ogXxPHOVHL2jVzw8WSwAvRPu3rswXa+7MqdDPEHLh7wgxh+9x0rVPHTw9jsVZaE8C3IlOVKVUDzZKdK7a9eyvLgQxTx1Ihk7tbrDO/1xerwPsMY8VOBSO5oPm7xIljQ8I26LvMcUr7w84KC8XTXnuyud2Dx+SgM8gQ/Ku/RPUDl1hpG7Ule7PJG3Iz1ZVl68rFeUvJbknbyl5hc94GBfOk30IjzPgJM7gWBQPa1S0zxXkM+8CekBOpVGqLsXzK48+D5wO9bPvDx2jse76m6tOjd7O7sa7828EW1XPHXNQTwJMtY8ig6tPG2b3bzbP5q7mdCTvN5EBL2yBRi83K0WvatUUjy+G9c7GC2FOg9k4jv89Sk8emD1O5FDUDtcFac8kB/bPMBpEz24SRU8wUSUO17wUDgezhA9oFfLumTfLLul6Lc83vD5vOeIRbwYRI68vMdMPMgzCryzKNo8k5BvvNpYHL1mYAE80aFGPMOfabvjvVk8ZjH4vNedwDvtx228AnyRPM+razw+CRa88GO1vDnQ3rwkqum8/HtQvM671rz8SFA7vCxIPKGE5Lu9X408EKvvOw0+jjz5qJ08xPwZveiKrLsnN2A7J4ZnPNOwGTyxRU+81BAKPQfczjzuxrW80ADpOtTunTxBLZE8x+EyPF6OwToeqSk9DGuavFp8KzypL/c89MCpvNvKjTzue408MDOGO88QX7wStig9xmbnvEhSEj3PLwg8BX/oul3xbTxyo788h2x1PKyzpTx9e/q7x9dkO3BokTy2+wY9vXhGvOWEiDzDwno8GbuZvEwTbDzpRSk8PaAEvZDS2LrTDeM8cAeMO1ziujxUbMk8PNATPQseuLxwe3E8z+ohvVvh9rusKaA8yKJcPDfVjLv9ypY86FDBvEpmsDue6hI99vzpPPbdJL3WDRE92zCOvEljEzw0KuO866vQPK13hrvp9lq8nX+jvC535Lw8CgG9O1eePCHs2LzE74s7LYm5u7b24bxgzji5aRmDPO4/sjzYfaS80Tc/PXqOITzicfM6wT3AOiHlBz2J12e8vMqZu/l8Vzsg6vM7xlymu2oG0Tu0IYA8/qDCPCS+2TztC1K7P+aXuyrumjuGzxC8pgeePK9SbDzJy/I8QfixPP66pzz7mzE8TGZQPe/vTLzCboa7N56lvA7U8bsLNdM7osBFPYU6m7xjc6k6zc3AOzapEzuQnQ89Abr3Oks38rxmiDM8hYP1u1CyZjx15bE7bhvTO9LQNrz9B3W81kHbuC9ZxjvMzgg948PsvOXAe7zkB+880KT3vKdcCryumum8VyxWPMHW7zz/1Ym6Bv1FPIEvkjtETQg9Y+w6vIY7DD1n5/g8Qa6tO9ZxiruOdci8lYucu6mVibuhDZe8DDybPKFSvrtb7Rg8AyDoOw7+TDtcnYE8lyXtO5nwrbxZhsS8bgkPPeOxJzxgTEm9hlr+PEFNDLt5zJG8h7grvEHPGjwIsJy8DJGQO70atbxBjTc97X6Gu8mv4zvu4Xk7KpjGOge/ljzEWD48QajKvM1FNz2OWxq8VjWFOgS0KjwjVQ08MZqfvNcf0LuE2PG76C3OPPiV7jv0zfm8NjbGvJ/UFzwqLw+86+O5u6EeprtvVMQ7N0q1PH/DWDwAVNm7Efexu+8mtLytPy89ouDUO7AQQbzQ2Ba8RH7OPHfe5rv6ASO9LJxlvActdzz2E588AaPmPLFvWr2P7jU8qErvuksJlLz+Btc7Ggy9PFxsdzxCfwy91jIZPUDP2DzIHn28GayGPIDhA7xCKsu8e4TYPC4LGT1WPYa8LGiOO6GxGbwtZMm81M24ul2sk7xpNO27QF4kPXRQt7sEQSS8Vt+Lut1mBz3Sqb48FtiyvEWFkbz+FBS8pglTPdFEejysEQk6Ne3EPIRsSTx7HIC8msd/vDIA2Lw4a8S7wX4Xu8MybjutcT4779iHO+NFCT3oz6I8htNbvE2N1rz5COM8EtemPJOuJLwk35i8fVo3vSf3Cz2T+7C7ezDTOirJFD1z7S+88VmZu0cVDLt5HvW8PWw1PI0Qlrw1oTs8h5vDvCjjFL0Tkxg8P9uduzBNBL3uyqO8UmRuvAQbiDy5aGu8fRMhvPssvTm54728HwSsO3u/97yGi+S6+R8AvBVsPj0bDK+8gEvmvIlGEDvUou07yXzhO0SrMj211tw7BmjguvMLKbwiPm07TkLJvBSQ3ro6NL28cQiHPNNDjztJ4l+7K3e+PHbpOz1jXQI8flieO1VIlzsfyJ48OOhhvN6kIrwzn6W8dUyIPBeYgLzBCyO9VLgJO34umbxuVdM8FplUPOPt7brDgWk8/6KCPDjmZzwJKCW8U+HVO3RI1rsZPuC7aMVEPMnj17r39988mRACPZblOrw54fG7sMpRvEBeS71Bhcy8JKddvUMSlDy7yc+7A5MSuVl6jbzkip87E5wcPSW4krxYrJ27KOKbvNRZ3TtyELY7irvNO0l4hDwHd1y9DIQOvHry67v/uwy9x60VPfvFDrtHEHY8z+kcvEQZiTwo9Qm9VeeNPOGkM7tCGQe9oh0SvcIGuTupsuo7HZhnvInx7TvkWqG8sTkpPDgYhzwaJIa9qvnDPGRhtbskWQS8rIuKvAcZEzvWGFq8s0GrPPWzBz0PTDG8uFiuu7cfjzwYvTA7qjofvNDdTzzpoyC8TAz0vETKZ7yy9h+8i02sufu5GbwO5BQ8iqSnPDyC0LpuUzk8/z1qPLmdX7w91fe7wHINPOxo27wMXs07HFcXvIinhryU3Us8Z+eRvFapJ7u1leM8KnBUPKEu1jz6jj48OiEdugtLXLxKmAo8N5L3utEMw7uDkLG8L/rAvIV/3zv2u9W8FZjSvJSNLj2ZYaM8lbapPCpvhjq3qiW80FSvOqvaED2vHBG9d+WLvNBn27siWLi71EYtO0muDD10ZZu8iruwu5Gp0bxgEF08u6ANPIpMBjxtqQ48ysXru0gePjzA4B68/Iv/u90+BbwIwwU9X7AmvVja8btu7R48DPGHutRhv7pF3JW81QdJPaAIBrwoVL48m7oLvE+r8zz73pY85TIfPHiTLzv2/wW63NkfvDwslTrcSj49vl/jPFtU7DtEDZy7NcDLO9pYXrx6nzC9DZBZvJRGaT3ZwZe8yOPXvFCLyLsSOjE8T/BXu0ivAj2Yo4g7EA+7PPSsw7xoKBc8hV2rPCqTmjx5V648spl3PMgKpDsC4L+7dlauvNcqCTutzik8RuNUvOuCiziJOdi7MmSavMTseDyrnxK8J62zu7clZTzIjLi8sOUPvKlWN72SYE89yOsuPBRFd7qQU9m8tvaRuxJxZLy1BJm9g9mqvC5aCr3CpIU83GVDO4zF8jyoYCU8q5LJPPOnaTtFqOS8o+lROzMMIzx7xIO6mV0yvLJIBbwnDMy8WxCJvB1mr7w1KH68duPlPEjknLxp7b28Vq/UO8PeYDvJcNS7SUCYu2rfyTvORAA8WYCMvKQe/Ty1ob08yKMYvALJWroLG5e8kULjPEUck7zxmJc70vHjvHGubrxHucm8kgoUPb2t7LwXGe68wJFmPGnYjruPaIY84yAWvKixVjyQnrI8f6tmO4nU9zuWU1U8DcGnO738GDxl0bY7SvGRvPcv+ju2qg+9MWefvLknujvheYW8pjINPICqHLyJn6y8KerMuxYv97xBHV68yPnrPAnJdjwxyAG8d9VtvP+7bzzW+vY7toPMOvRWhjxu3ws8KocqPD4TSj0hvwY9qQK4vMQl87hsrtA8PAwJO2CojLtoPAa8ZXhkPPKDUjzVPT88USCXPF8qmbpNwZi8WCBbPFk0HDxdn3+8zpWTvMsFGr3idvE7URaovKeXNrztLrm8q+YHPMe+47x4sXu8nrEHOkqpOjwL92y6xJF8O/81vrsk5+K7oEOcO7MYHLziglS9UgRkPbcZ1zwx9JE8nO4MPRRQCrwhb/W7wkryu2Erx7xVcek55TDAOlzgEDxdTJe6uLCiPMUoq7wYLY68OVy/vI4IxbtvggW9mcRlPHL4czwFY9I7imx1vMbQyjwbTkC9mMgaPHm+l7zaRtC6Ttl6vLm93jsf0/A7VLS0u4YVnzzGKjO86VkhPRRQuLwP5sK8WilFPHFLkLrFToa8mPB/PB+ZwzuRLBa9nkdqPNFZp7w6pj48Vzo6vIwRfbz0n3C8DKCOvIU1YjzVSl48B41ovCyOh7sJTC88yR1EvFXPpTy69ZK8pNusvC5dSjuY4w68HRxZPCJ+l7toiQU8/hgsuzmCWrxU9xm9c9APPNkYs7zT0Kw8nhwmvUusS7lIyvM89ZyIu3UolbxDQGS81XLdO1l4tjzAqxG9qNZGvGD/IDuEKNG80qAwPPHy9rzWdYw8j0cOvfs1nzwmc1U8I9LTvJByjLskbIi8wGENvIR/KTsBngc9nw4MvefNnDvpb8U5reutvK3yQrwTkbm7iFTtOo4bRzwBPly8wCGIuohyKDrjwpW79R6jvP2jqrzB8Hi8H9KFPEWMzLsQtVe8ymXzOmxdWLrtryu7nl/GO++z6ro0mIG82iyPPKkncLx1NT089r0pPUUiDD3NxqQ5f/sfPevjh7xs7EM7AVjouidJ07x3sz08+ro0u6AwpTshfKc81d3rPOZyhTynZHq8rmMivatkOzy0o0g8ivUfu1a6IzysSg29dUjdu+HNmzz/a1m8UNagOoxQ3LwgxQ29RYylvMwtv7tk7HS6ibGyvBZXFbuPKJm8dKI6vVbeGDy7wwc8RNdiup6UbDnTq5Y87REgPJsL1jweGVq7PrgPPdfTwbw6pre8xoU8vc9WAbzBKNw8h26Wu0Eq5btm5No8XVdIuxfrwryO9z48kwEXPfIKDzyy0L68W8ivvH+jybx5LvG8S3cGPD+dfzweHXW8fzqlu8Kx1DyoJ8A7+CMoPVFC8btdeKI7/rSDvNK2xLzPxYO7nR7GvHoazjpP8zm8nhJsPDFC7LwhZei8Q3AkvLCd8Dz/g7s7vz5DPIaf6rwwTiK7mGyNuyup2jyuZuC7E2vnvBEb57sIu928ejiCPPdhAzxy0xe9hW3wO9JJxzto9pq8PUngvAIwFDq54z67HqFBPfHKlzyWO1q8U7JBuuYsDrwB0rS8fZQ9PFwtnruJWlA7lq8fvMQAT7umuI081bx+PI4LSbwMot05dt2FvKYCVrwcYzG8SQeSvLAWwzwwPBE9BWrWvBAxpDxvRD89ClUlO19V4LxWLEw8kAg3POUmET1lbBY8w/61u0JYsbyZRE67rzFjPAgGsLxcQH681l4MO6EmB73paJI81FdCuy0tkbz98XM8CdFVOzbP/zv5ZrI7Ee3bO4l9RDx8KRO8xSrjuSiyTzr4s608GqbcvBxDDz29mp+8DE9EvH5Irjs4yLk6V7qBPEMwKDzGONM8zEz/u152G71EVVu8dK4MvNCaWzxJ6zK704n6PCmv7DlN4sE7ex58PPWPAbxXXZe8KWYyvJSACLwji727mEzTPLEd0Lsm9TS8l10hO3cdIDyr8Fw8CB0zvBnBVLzvyKY8lFQDPFZQhjwNHMm8kVURO4tBdLzOk+m8owEkPbt6dDuOWw+8oXa7O9wZFTy+P9K7LuJMOyURr7yBeJC7GHyTO4rGKjsu1Vo7MRkqvFnz67veOQ+8hBquOcxNn7u5XT68L+orO6DKxLs5caK8/7AQvWhTnryB/Sw8gBkGu8Nk4byqCTy7P3OOPKZZKz1F2vM789vOPBL3Rjy6TWa86yUEPf53YLybLPK7pWNkPA/d4jpaTck6EmSuPDinJb38SUK8spY0PSizZroN6Wo63ToZPMyGrrwbQ1C8Ffy6PNZRvDye6sY7qDuXOwBWPLwlmLC8BS9au/g69DwANBQ73BggvCxkrbw8diU7GZ8Iu1L1KTya8Ks8WktXu+d9TrzmP4Q80Qg3uxTrH71+wNU7T6CtvCOFkDxKCNG6eQH6Oxr5TzyiIG27ijJEuXtbEjxLI6U8WNAIPRYR6zyOAdu8cHMZPZyDgDwAgLI7MPkmPPNWmbtwtnE8RDY4PKhj2ryrxYC8yJ5wvDcB3bx/0gI9xSr1POWywbvKTc+8o6nDPNIAi7vUhOC79n2YvBwKpruv5I+85w0du7sNp7z26P+8RI/bvMBCvjzPePW8dqMEu6Oxa7yRet+6kjoDvRC4fzzqDnS6nQU7vJAOvDu83+m7oC9SO8bmjbzMX867VOUsvGNoqTuqSeK8z+2oOmoU+TxGspM8t+kIuxtrUTwGXuY7NECMvMSLBLyec4o82TLlPDQf+btvAha9kQinPO2Wt7xzrs67ZO//OySE3zxbccy6oCR8vOekeTzQfC+9AdP2u7nE9rwgULK7GXt0vHFiAbxpQ1c9NxJcuiwlsLt4L5Y8rBv1vDSk2jyg7By8wJifPH+6MjzLoLo8cr/bO9VdSrwRTNY7DA4KvI6N+TxfgM47uSQIPUX3gDxqHjM8tkIwvG4hq7wZ7Jg83ycXPQvsyrzPfr68AbQivAiC3Dujz5k8qsIPPMG7Ab1SSqa8aDYKO2dChLxjsIA8VPyHvN4c4ztyUXS7KFeavMmgq7gCIK07KA+UvCEphjyMCCg83PP9vEjRyDwZv9W7HkT4Ou8OPryX5Q28HzOivErc+Dyegak8nCxVPPgDpbza2RC93RuGvEkZhLyXc2K7eCmNvLshqLwxjBe8u1+kuzXrZjynGYG7hwLSO0pLGL2xEEG8dXkBvfOcSrsO30y8JRcru+2bCL1wGa28eQwePGPXabxvl1S8leNlORxLHrydlhY9Kgb+OfBiYjzoVag71lgKu0hxILutomY8xBx7vNS+yDxvEdy75eBEO602pjyo3Gm8ctg0PI+6TjtkeLi8YR5cvH6MxLxMXwk90orVOXJzS7yk7D48iNMRvRWwVLx1ILe7wo3pvGIW9TxL2Ik88j6OvGc/arwczOc7C1G0u9yH6DyiP/m7+diRvKm3gTrIH488eXelvOeJjDu2vWw7uhREvZPnA7xVJCq8mHX/uwo84TyE4Jm8oHUHvAm8/7h6Ez08awcmvI/uMTxCk2O5II8xup2UlLynuDw8bG9zvLY9L7xlxcG8jzlEOQqIBzxwZgi8KfJ3PAKzJzwJHei7hC5HvNUrsTw7XGQ7a+dcOvSojDwatQu9y0QEO8kEmjuWYIU8zkk+PHuIFry03d28Mo6OPJBxDrnIkgC8oZ7du3Ht5LtMT+u8jzPuPOs/ZjsmLTi8bbumvLxdZLx4FRo9tAolu2Q5azxumfA7XuvsvCyobrx3Um077i/TvMgsjLvh+OK81a4gPGiXB7zXLRA9IKhxvKUNQbwJ2JA7RNYnPQjUG7wdvSo9sGdCPIatWbsPBmw7c/mBPMHJSrxKGQm8I/qKvIRtiLo70oo7BbqLvN0teLuLqfe7QwkkvGvRZLyacn471coJvcUAJbx8VAS8fj/aOzQaMT34dug7BEesvBBjxDsRrZc7A7J2PAaarTtz1GU7XEkHvQsv5LuauIa7zBfWOacCkbvM+I07r72mOmYJOjs4vjM7a+nSvMZp1TyYuda6eTCsPGUpGbqo33u7kVbRPDU6vzutvuy8EszwPJvnkzw4wSq8P6vvPAbbz7zcDJQ8gGZhu29Q8jyoB7y7b6AHPcnhijsOPLM7vm17u849zryxx6S7fgPROxQ07zxWu1I8+CCHu95N1DwiJ8k81FmaPNXB4jth5yk9IK0BvPkevLxa7nC8o6eZuy/YiDw2Kpm8iLWou0FcjTo9Pcm6zt2oO93tDj14FFO8g9nNvPaHoTx54Um8rnI2PfyaJjugjx68DZ03OjOHZjuXazq7omjtvEbhQDsVIeE7k7H/PNyaX7uk6ak8nZgsvFCRqTzWqkO9bQSMvOCdBDyh0o86BuIqPAMzdDwG5zO8Kl+hO8rbZDrQzaw8D56Eu0LgOroD42M7v5OkvIpenLxE/JE8ZOE+PBQaiTuPdGg8w5CjvGTXXzz0od877jNnO4gpYjwZ4jw8yg40PLLqpLsg5j28Ll/2u9PUjbm9Kzc9zVGJvD91yrtyUZo7AlIhvMP8EbopoNw7SgBsvN+at7t/eHc8fmchOiiQxzqZ7Du8QogIPM7jObzyyII61wcgPOKY5ztc+xO7fmWmPI41RjxtevS8DR22vBcl2TtmJYq7+lNJO2x5JbymQno8PC0fvEv8OjxQ94G8f2i6OlBLMb0524s6JYfqOQ== + - embedding: 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 index: 0 object: embedding + - embedding: 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 + index: 1 + object: embedding + - embedding: 63qouZSSAT3CyEC9fY+BPMy7nrrpcyG801loPdEs1byokoo5uW+3vO3LGj0taRC9zOm8O0KmvDzutuW8QAOSvM7WF7x/3z88qrJTPNnV57tR9ay7vj7yPJZ3sD24jjw8diFkPFqrEr3k8OW8+sCfvfXuVbyAnJo8Mlg3vWpCnrxL7AC8DyWbPP60djqhbWE81vQ9PMeThburDlA8K7KvPDwTg7xK95o8kWRMPHB6R7zyKqk8nyYqPOKZMzx/92m7ujaqvBG4I72/HkE8toAvPKoIab3GtZu8zs+TO2VtBj1oL+48ojwMvMoRLz3NRS68NkUtPN/UtzxfAkA8KVqXvHf4vbvS22G7a9TOvDXpBzvhvEy7QtWUPLNSpby/X7s7bJMLPL1mTbzAFak8M5qCvPopX7xwp5k7U6nQPDeU+DvixPY7lHvXPKBHi7powq687uLlO7y+Lryk9OU8OWqOvA3pJTxgDm48vF92PF83tzxv8Ts8/zMSPQGOwju1H+I81tQXu77hAL2oupu8QyCRPNVEezpzmAK9X5gUu1DgW7u/0YM7UPVYvIGMU7o7zGE7JDnDuwo5gTz68LS7dmKlPGGFCzpqonW8vP4KumDZlzsOZ6O6ZOUYOyrkBDzawPC8myYaPPeAUDxoCCY8UFALPPYOV7xCeIw6egEVuqXiAjwjPUs9Co8zOzXo8zxKYlC8ph8BvJ6IZrytGqw8434nPJ8fZDvtcSW8y81PujbvWTx1kYC7uQcrPP6umTtsddy8QMGsvDlcsbuXsrQ6e3ADO1Pp2Tve14Y7yHGLPG4m5jjoo4e7saPOPEfAKjxdECc8VvKMvGvlmDw3C+A7GJNiOGupYzsw/S081l/eu7Otd7srsoy8BWOSPK/dhrxUqXi8YwEPvGQvJbrHShk8lXkau1JKe7xYkoq8pqqEvLKkAzwuzha896CjvHutkLxyF+S8WRQTO++ixrzeo0k8d7VHPCF78zuaFaK7SG7KvHmDwrv6sL85fr2+OrjTJrto9pW8ftlUPDnTzTw9sQQ72z2OuKv9Hzy0Yk4862jnO7fUkzoO+448XGzmu/pwl7w/dkS7m62ju4B8krtITT487DnHOSD5LDznefy8elyvuxxvZ7zzzWS74ht5u9tiwDtRbsU8gYFiu2pfS7sbiIk8/rdxPDNTizwN0yE8pVa4vA7OpjxlvX68l1GePOlrbLvfarA85WR+vMFuQ7yBwjs8+Ne+O2hj7ztj7Fu8c81FPCEqjTmux928pz1bPJ11BT3GFSS9Q986vUcAL7vaCTo5wkTbO0h+Hru0sbK8Ke5yPLMsDDuD/is7vzpGvM64Dz0tCX08xaDqOyWNPryao8O8z4tjukmFUrwNnbQ8UfNYuzw7+TusS5I8klhGPIr2TrtGkJM77FMovKWNXLyLTUM9+9IUPCmyfjtadZE84wlvvBgC0Tuv1kW7i9qSPNTFlrxwhba8phqbuzk8gruJkaI80gVUO12jqTtNCyW8/LBsvND3gTwNEzo7z1nfPE6DqDxOPNi7xKccvIesQTs6X4w8N/kaPaLKlDsVpCW8iirKPCiw+7vQG4Q8if3Nu/OjhLyIA4W89AFzvAQsy7oGQFU8z400vDH11DtzTUE91iBzOnlqIbt1Spa8WEnWvIYMZrvd/Kc84fJIPJC80jz50YY8QGi8vC0xrTpTAeo8YMPzPEbIYrxZ0LK8N4gGvcflEbwjP007gWYEPKDxwDznUFA8fbaGPLzhc7y6nKM7/0a0PEzmhTyO+di8wUyaOnwhwzvDdBo8z/V5uxMZEz1G5PE6il26vBzpD7x0yAk8ZodVPVRQyLvJ4Ca7zJopvLskrrrBpEY8o2B1vYDjKjxVwIm8AZ83PDuuG71Qms671lqzPOKF+DwNHRm8jFvqO2eqCT2Ab6e8xspCOz7ru7yuF7M8x/1FvF7ZVj2BWAe8XuEavKoELDxHl9G8yEVKvLdJHT08k6o8CCbGPK4WI7yCkN28R+SqPPTqVT0isko7u9l5uzpR3Tynevc8NAaTPCDZzjpf2N08jYuxuxX6jjzYwCy8Zf6+vPb/XjzXLFu8FlGaPPWdv7we/9A8R2T+PNkANDunwO08dAvDOyDamzxU8Hi71D6SvKh5C70vleu7twLEvBgUdTywSkk7EXqHNsGijrz6w6y7pL66uz3SET34HuM5fGWBPBAWP7qJ+G48QDJNO1XynDliRdo7TsqPvHdWCL2QfWM8SZuUOpoRHTyuj8e8Fd7KPGMQnTxnyrs7uFcFvaiWRTwSvR88vKXKvFWu1buesEW8RkqPvMy77Ls0iUc7Xzo3PUSXdjysm3G7oGG6vMET8bzPLra5l/R9O260zbti1dM8gXiDvHxugTui+768zCdXvK4MgTsN4HU95M66vK/VALxuQ/s6vOsdvI0n+rzwlxK8Wo0+PEAcojz0mZK8NGrkPNG/7TwtPg08TDiMvcLrJTwaMI27EgoTvNxeyDt2iLs5GLedPKNLHj357pE7THaivEFGBzzZTyq9QcG0u4ZS/zsl/bg7HLdjvCi/wTsZ0/47zTO6PJ++urwKB7+8yiw1PK6vwzxHlQO8/sWLvNnOtjgQYGQ7LRu2PDqcwjqDbnI7AHYCPewgAbzvI+o73erevKJf/jsUszE5NeFgPDPNszzJIfq8Rij0POTrV7y+6oq7gx8RvFHaULrmm5o9fkkEu8+EP70BF2w8bNI0vK5spbpcovU8S0g6vIgt5LsxWf680i+cO5TyGr3E3U08RA6Qu9gGCL3IGnq70oGovMPH77sriAC8NMI4PBuzvTzSIj67ABgHved+BjyYkvC7deIXvIUBlTypVNu6GtozugxEh7yJ4Yy8wJpvPAz9jTyOdkE726BevFFveLvymw28sktLPBEvWz0CwCE7DfdKPB+lQDujPhO9ENdwPPWnBjzegV+5ysLKvEQFLLyRA7s87FgGPHBf2zr87wE8J6OWPMzg1bvNDNa6V9ZRuU5DmjyDN107x4KSup/B6DwC1nE89fYTPbbyGT3cjLi876ShvCItKD3Ucjg8NHHNPJgcUjyB6iW9skDAuqhjVDzikqa8sHRZO0QILjosvjU7W0YDuoqztLzw1VC8Ie8Dvdt2gjyWYek8yF01PT4FN7xS30U7D1PNvD1J67p5NuQ8yVeVO8s2S73Isac8NcxaPKcMg7vseqK6GSvyPAHXYbxJ3dC8u71VPKalgDydQAI8R522O8sj9zzggwC97NXHPMvaIjql9Jw7z0u5O+TXpDrmkgi8VnRPPEOKUTyYNIK8U/0FvRoi/jy+NOC7FzBRvMQS9btK8iW9CsoavcX8LTugEO07H/xCvUTAeLy9jsM8PxvRu1RYSj1FLwa8MgOHOvl3rbw3WrG7XUumPI9pvDtA5mS7oO8dvbxBcDvjk808eGgbPbj2LDzEZYO8B/grPFA+DbzLusI8N7m3PFM84zy7+cO8VB1xu+4rybsDNxg8S2Q5PJVrJz1T6BM80lVEvW2H7DsnOjG8XoJUPH/9LDykZqq73rnXOYy+hb24JCy925bqvElo37uFEt88i5pPOzfJjTrOxni6VW1oPEm1fjwnHZo8KwipvGLgVjwpr6m7DJgBu58g07wAvpW8S8iDPPlCWTy5MZs866JTPD/p97q+5QS8Dyfsu/U1hbzCH7Y8KyRbu+hOtry0MwC9RRwAugn2ET2ybwc9i9ccvOvAubyiKU29xRNjugSuJr0KL7E8vwHfO8aN5jyUcxi93q8mva5EvDzeerm706A/PPzKFj3fRUE9EX0VPPvPvbw/8py8R/YRvMzkdDwrF/w5okAEvH376DzQ/ay7ulIQvCTZGDxXZNK6LXlkPHZYgDuCH3C8n5l9PJ22B70VceW7Z9S7PPBakzqspSI8HtMnvVEDvTxU+0C9xw+zPEBAAr1ba+65hULnvO+1PjwrPe87isdRvIu85DysIUQ8LJU+uWpRlz34Onw8WYmfvIR1fjwNXzw4snZfPJ9i8jw3FSI91QpXPC53Ezw4v7U7W0OePOLHrjyjAck8EG4QvHQ4fzyBDyo8AmC5u2rjHbytB5y8DfGnPMfgtLxtk9c7Ms+9vFWWaz2glTy8wkHpvHZvozt1YAQ9FzcdPfdy2Lx33YK8KE0ZvZq8Oj3kpO+6q1fkvN5AwzwluoQ6XOmZvKRhCzwEZmi81RoDvXvTEL3Jmak82xeJvDbdQjyBgZq8EW9wvL5Ghzw4sxK9p7fLvPqFIbyLs4w7Jmg2PAonPL3K5Rc933tju7iU97wa/WY8L9UTvDtozbxeAYk8/OmbvBkSgrwC3PM7hQ0HuhIBbby7/Ou7eFMhPcFaEL0jOwm8PYKxu3koDz1g8rq8RsfmPNFda7zxPz27Ea/xu8UEArzHpbg8jnmPvDgEUT3pWrA6FRg+vby5DbwyfcE7u/tNPXRxx7tipW23BguSO17LlDzTBV67tqE2vcARM7wy8wI8TNfTPGZRlbslmYg8eXJKvXNOnTxGc5W7IiV8vFBTTDzWSn68jzCJu0PlkjtHdWA9aeERvWriUbvWVZQ80O2RPHPzxzwE9XK8lCvLPJIn5jrbfVs8WprqvLSiBbol7rM8ETeXO3oE2Tus0Ku8G8nsvFNsjLu9nzq8Z6aiPEsopzwl00U8umzUPMqWlbw3+Rg9DuVTu80vgro5tL46mq6GPMByDTxvA4W8E39IPandAj3JCZA8/moHPSjMODzIwaW71NpfvL6nqDoyxlk8fr2ovCvNv7s02hU91PCJPKkpHrrC6ke9JUCPvHaemTsgWDW9koc/PCMLsjzwo5C6ZEfHuy6dZru02WQ72OaLPNyFgbp5aXo8dVXovP4gX7xp1gw72K4ivIDuWjwyuIG8T8OMvCtzBzzxzlk8vVpiPALtKjwf7tM65+GkvNYyAzzk9qi6aBM2urbSQbxl9Du84F03vAP8ubq6cTE8/UrCPPe7EjuApvk8KVHcu90bGLzQtkW7aO47Pabu1Lwm5gu9a23Uu/sNKL2kKiW8MeGvO60XHLtnGz85m+BYPHjEsry8als757lauscX6LrDpbK8LqoQPZxiwbxGVcW7195+u4gF+Tv3hhO8mIgDOnQlwzxgy4s8LDMUvW3jwTw4Uy86uMrIOy+P3LzdT4O80+C9PML7Mj0NM6w8A6aVvO68WbxsUmG83W/eO4MkvLxLnBS8zR7/Oz7TJ7wQ3q47Iwk8PYniHD1jugK8QrCqPA+uWDuYbvS6B64AvfYWLb22IAo83t2rO0TRVbyOELe7n14VvRi++Dv7tw+7t6GhPMcBtjwn8Sk954o1vfQsursUO7Y8rVjQu9O22Lz/ePw7mxAjPIR7R7wFSx672pSbvIFqzjnQT4G8dPI7PTjAyDxMYe07fiyGvMNshjvWnYo7uhfxumfB0bth4hg9ND+7vGFoKTwdiwW878xoO0pyQrz5Oxi9pzVzvGLymzv1pd28RotsPPajVzt2Lvk8UB46vDNcHzxk0UY7ApCUvAygBzyPALU7u6MnO36KCr0jkJQ8pgnzvCqSgbw9jDQ8rJIaPP/BszzS3vo7MTxJvFg+W7zLnqC8eR8CvSeACL0JRfO7cxCXvGZOATxwVyA8rQECPe7hHjxZRXe8vte1vGlCBjzwLuk8tlXgu+W9hbtfGR+8DgsOPVyymztFlvO8Npj0OsghwrzhgwW7XsdrvMZlvrzWUle82YGWvKRrIDy5W168nnvpPJpvmLvU8iY8CppkvID7Kbw904K8XlWPvNGcNbyv6gy93zi/u3PB0Dx1QBi9etDsO413zzyQBi28P7CaO8djnboLjD+8DusWvZFo8zsSzFI8+X6zvO2OAr1P98k8fE4bvO0sUrwOg4y8EYHxvJO/ybxtQhy9hGO7u8ksSjoeSzu8FgiUPCLlvztaDwy8PbKNu3MQQLs9F7S81s3mu9KZebzn6Z87gNigu03m2DwzADu8e4AzvYx+8rzOFC06VTsFvFzi57w23hg9UGviO/xt5bx+If08zL+Zu3+TpbxoXY47zTWWPGAGGTy4mDK8WNMkvJRlNT2mcx28Dp/vPEUSiLxdX4g86u6RPDcB1DsxEHq6cPj8vGR72bsVX4s8PZjRu4qOk7ytfD08dGp+PJAQ1bs1Mf+7IVwYPJb6przLypM83SVWPdMrnjxnENY8ONpdO2SJAb1s9II8HrSCPCR+Tjzxaw09iWOSvJswmjusPoW7i/AMOu+YGzwDWLk8v6cOvSLOGb1pc1m8XmqTPIWFvTpeW5G8KRS2O6IZY7xBN3q8Td4VPRDb5Dze/YQ8DvKrO5XO8DyYBlG8vgt6vPoekbxm/CC6UvAqPFcG+rx87826x32/PCndXD3qBEG8VQ8YPbUoxLxRloQ67WBWPDvqSr1+OYG9O8OmPN/VpLwFRxq8DDmJPJb+ITtfQyO8aGvXO398nTwzvCC9+q4/PepIhDwSyVw7jRNTvGuRnTxdpaq8ya75vJ5dLDxR+Qm9qUQBvXrUyjxuasM7fWaqOxmGF7zCz6e8iPKPOwKCBb0qSSc7WG6hO1W/iLx1X++7INEvOw6yHbww6+K8TcHCOwZcHbuzRRM8aRkHPaNtmrxHeuo7TS6MvE3D4Tyf94w8YbB6PKusVzxGCqc8A8OCPOkU/bsXlrc87DYovH2qNr0hKD08AnajPFboAbzPmg276M1PvFYd17xSVfk8lIGEvI15hrnOhR49mFiXPIco/LunQJY6XxpKPMrsC71IZQs8eFZ1PWJynzuEKes6nXpHvKr7cjuOQNk6Vq5gPDusHj2lkgA9ezumPHJFrDwMaQK9CuAgPcpwRLvSK8s8GFduPE1tXTzPtkK8re1PPTcziDwR2/K8smkrPCRcs7yioLm6yHXNPO64SruhoWU61nDmvGeRyLo9w5i8/V56PM1iYbuDtQo90SwWPOCH0ToAl6E7ylqpvBvLajv/nP68M5yTvNAJNj1Na6k7Wu4xPJu1lTy/SRg8x9n0PPfL7rs4L/y7EkEWPKunETxbexg9z6SuO5Rw+7zXIBA82F1zvPTpSDzg3Du8lKQCvLSIArznWBC8vB4vuy/pjrszpJ87/UmbvH4qI7u+keE76CxuvEl0+Tqs5oA7dhidPFaLszp1rR8913OFO/qxBjwLTrs7LDQivEtAdbuqq7q7+qyaPAlSqDyxkIk8AepSvM93nzwoKRQ80WugPO9EkDzhfls8poHFO/5uo7zVGTO7u9mJPLw/P7x3KYY8XCBuO6czVzzvGem8NachPUQoLjrTBIO7xWTpO8HRGz09zyc7YC0IvJdJYjz92yY9lGQDPaQhoDx3gDi8uxQrPb6qND0E4ew6KQDtO8vFw7z7EKM85jX5ujVM8bs1XzM8VhKKPHS5KzyUmJc8VP6XuyLRKDxCO7c7+7BDPIZ5e7y/7am7G+wUvLTWPrzHe+I7DLxKvN+/xLvIrDy7IoxFu5wgszvoVpY7VdCYPHpphrx6wYw8xycRPOBzD7xeyZk848vDOkp8Jj20Sj67fO9KvcIMgDu0Zhy8BMi9vFgkAT08OMo6729XPNwIyLuRe848s+vKvKtqHLzDG0k8uiRHPDUIirwWeF08JjirO2/dBT3MYTG7rIqWO70nSbwUVDa8yU3kvCbHYDtXnbG8wLSivMBHJzzyMQw9iwLIPPTD7DwSO188y5Y+vB+YNrzEseY8FDlHPNtvOrwDd5i7miAvvOFcMryE7W66fuEEvRnNYDxURHW78FvdOxAT3bwIvBO97HIDPUuM3jyN+Ys7xjYFPBhWVTo4PTI85bkLPcHklbz95OG5WXXVPNZyDj0p4FW92JnjvDGE3bscPdK86DoJvFOLGDwnQrY751HDPHsB37wYO9q8IslWOhQtAzdvSu284ZisvHq3zDyMGSc7pQqAvGPI6buOY8e8JJXDPHFQoTvXJaC8kuvjvPMfJTymq3k8+ZbJvCao+LzJQsG6OnhIvACDrbzZs++8XCdBOUgLBjzW7ci8IeDqPHrY0rzOgDk75/RiPNF9UDy0o7K8gTlKPTksaLxIIsU8IGuRvLVXhrlD/xY8giBPugEqpzy9Bim8bcmKvHaCzrxmmsk7ma9YuxlyBDq9Aps8yf9OO1QHijxxm8a8hEejPCsR17y1HN08YSWhPOCXlLvnXlU8zNqcO7Dt5LvolIC8KpMjPGExUrwCD+I7i9IyPIZ/wjzi4CO7t9OzOnjeR70JHhE8XpnxvEJe1bwukZQ7+6OEvBMeLzwSS7M8nGaTu8vqebyhBby8gPJvvO7MMrzKtlc6IaUcveqRWDvG8FE8Ce4PO7HvszyiwQw8739ZuWqexDwEHkq9/skPO0TrDT0EGyA8Yc8oPLxdQbsO5ZY7CgwbvN6fp7zxIq27qiWUPJEoDTyXvka76J3NPPzSQDwdP+265psMPEKfejzAdSU9W3dqOhhrYrzYCoS7lOYQu0zw3btUU2E7aOYWvIJIwDy+Cb87umPxOx2qFr0uYaK8UVbCOsLtV7w6UMQ8N8quPP3dkjkwflk8Lbc8PIg/JbrhGDo8QCUivGWNOrurnbq6q4EzupS9XbxOhPG7nJ1+OwA0yTwLvKC7/jXeu/q2uLu+EMq8+cFGvfOvPL0pPzk6SjGnu8lzgjxs0Q47Gw08PAckNjy6css8YqEovC8WmjtxEqC7wuTLu8QCq7yewLK8fLtkvTCXJz0/yt28YO+su66eS7x/Yk28x6Q4OxKPAL1yTTy8e0JQPNvWxjyIMzy8gfwlPA7x9LlOoSm8CMsGvEwo7Dsctyc8Tcf9PKh/hjyzB8e8KMiFu9PCWjtRX6M8A+eBPFRd7DvH85a803XCu5RjerqZB628HqnfuQiFqjwwiJu8lZ6Su0lLCrrUgek7RS2YPJnLGLyOPEY8+Sr3vHpC7bvYIKG7CO52vP5TpbyimrE8fCaRPLBjM7y6cVG88h+mO2PL57xsQMS7D/MSvOLuiTtqXlk8/zzhPOhHN7wtudS8f2Giu9HAmDzr/mS8KuE2vKEe7TtaUAA9xLPaO0sAIT2pgUG7YdWOvKVGNzwlKNC8Wx55vPhuQTxbwwQ8H5HMO8QlyjuSYue7/wygPJVBxTyPX9G7IaVqvDDKvLsR6qO6ExPJOxrDN7zBqMS87UMsvDqZu7xpQco8rLKPu5erBD2c5uE7zSCuO/yoiztiE6W8dxr6Ox67kLzzylG7bevIO4YGbjoV1y48ekK1O5MGA7zN5io9hJetPKIlEjsWeju8gEwXvCgFGL1I8cI89tXFO3J+UbuYrbA8SZ4rPDsEDz02/uy8ab2OvIOD27xI9xG9GPOKvKbT1bkuhT46s9XIu2BJtjwz4XO7NhSxurtqDLzPKte85+wqvRAOf7xula48fzrruYrP9Tw4y8m7mEADvCZwxrrIU8m8jhHLvLxhVbs3z0A8vK2yPIvIHL3h0KE7eI9BPEbFPTxTxpo7MtA2PRWXXjxpC6A87trLO+S7hbwAfFC8WYfeOj1/oLxnL+q8Ut0UvcI2yLyogL4819euPClvrrzoBjK7/DgjPMhJbrvw4zq7P2c0Pe+gCT3kHe88wyz8OQeIFDwM1jy8Sra2OklWObwM9X08yB5LPDoCSzz7MKy8OfSCvEgzdbuKwK68RCFCvIpVezs7STW9lSjxO4c0Jrx73rK7iWW4u4fBvrsQzk87cUN7O3f1fzrNABK8i+3bvHXanbzaHNG7TR7juzKSzrtm5mw8WIgVvQHNtDwcuKm7dWTKPKu94rxcYw09bQQPveVawrygIf28AjNPPJX9EL3v4Yy8C3rRu1r33LtcrtE7fQQhu+6iIjzz4hs8oTAKPBcAvLwC8iy7b+BgOV2lAT1XAQS7EyjGvGaxAjwuzoU8pWRbvE5ZKTx2lpa8CLHtvKhI1TozcDo8gRlLOkdF/7lg9N08QNaoO3Ow/rwD3GQ7yV5rOyV4IzyWkwM7p/4fPKNIRrwemM08HuPGvAQAubyLoFe8KbygvH6HkbwD04q8u6EPPF2omrruCBw96arGPG7h+Dt9PkW8WHxqPHw8t7zVnho9ZfJou1ZGYDxpiCM7u48BPPTYlbzMt4c7i5kZvLr+K7z+phe8c17EvOpK7jvJM5C6Y0esvIiwAT3UzkI8MY1Iu//2VzzeIBq8A0fsuy2zsbwdhIS8mkbYO6ezBr2EGJW6oYgEO8FmzTyxPz49rGeWujf0lTw5/468DVAkPG/6sDp0nsS7aezdvBuwG7vXTXi8zpuiOwADRjply3g6/sCsO64JrzzwCgm6RxRDPISuDr1O/Vc712mKPEtiabx2J++7lZqdvAWzozu8eMC71amLO709cLzl4407EzEBPfSh9rzA8oK8LAI2ven1ATw8J768RxekvAe9RbxTu5w61ZLlu2f7irzZs2y8fgeFvHdKT7xQ/bG8lnsbPWbkDTwk8yy8oBimvCK89bwEOgy611/BPGi0cLsnuMs7hOgxvMO4vbs4ucM8TOCEPBAbbDtQAwG9YUOVu6GV6bspUc88tnmwu+RbKDyzSB29/oLlvNVg6jtarAC7QFiMOWXkz7vPVkq8X51EPKY43bv2WnO8U+UtvA094ru6e7+8LVxcPJAsvLzYhOi81VjcPNdU5jyP5nE861VHvMbXBrzz+CU5p7zevBdlgDxkWPk8m8ccPArEwDsXxaC8r7exOu9KNrwN5Zk7dvTEvHsdvrwTQyy9dDEhPdjpsbxkqGM8P5tAvNE70jzYQx88dMXRvGbyk7weAYs6SdoAPb3AfTzx0dG8O+ULvEzRC7taNTy9ifvQO8ynALyOWmG8FbMlu15bi7wAxjC7U3+AO12Q+jy2g/Y85MYBO/l7BL3bj6O8cjaEvISJg7tfh5S7k28rOx37hjwKF4Y7N5QDvfT+f7wncDI9BQAwvNgAaLu6Fc68WxJfvKCeiLvf4Yi83j7BPH4VDDw7n3W8V2EEPZ1k5Lx5ega8BvspOSxRpjwi8+g8fQeRvN/USrx/KH29QAzBPKELUbzAvM07gYXbvBYHuLmNXjo8rIxwPOQSs7vQzEO9k1pNvee4Az1uo828lZDjvO8PHLupl887IFwkvNDHZzv7kZa80kQHvIGP57sCQLO86u9BO1b7cTsGbGe70TdbuqVZILzw/L08ZBWduzzpxrx2Owg8uWB8PJnzpDv5/7Y6qodzvOjlPz3+LIO8LUKDu88YAj1Hs+i8g9otvCuiMDrfqN2793CZOybXBbxUEbK8I8StPGcXkruHyrS8g8+VPJn1F7wVPQC8a6y8vG6gIj3yaJW76flmvKQA6DouUXq8L69zPFURnLwygC47rK86vCORGjvgT9y7ucSJPMflD70e0kU8djMMvd447bvsacI7nTsSvXrofruFAYu8dGYCPKJNBLwM4jC9RaiUvJThILwU/aG8n0F3PHG8pzxNMQC9zzQuvJHSKryh1Te8wkrQvOMyS7ssMUm8/h23PO1Mz7tyjsm870qBvDbu+7zZNl88ZkKGPGA8ibymPC48G0COPF8sRDwAJ5I7feujO/xJ5zwZb6I8uF5APNoUnryF3sm8y5gEvWuZpjuJ1Fq8QqWcvB4BZbynlLK80FJwPFLoBrzVPJo8QQ7rO8FkVDxGdc+8cWMKvGhjKjwMo+Y89d6DOxEziDxMKOw7SSZZvPkULTymiFe84moBvNF9BD25xxI9QB3Gu1ofC70oE0k8fms+vBdl/TuPw7w7dK8wOoWNRLsN52S8fTV+u4B3dbyzAPw72yZYvOdca7wfMAk8RcHJvILQ+zsgSlO8JHccPe5Ph7vc0FA8K++IPCG/uLxTn4G8u/ysO6Nn0TzRXby8gH+9u3z2Tzy4bHe7lHr7u11NjTx40DU8ReYHvbOFKLui0bI6v6ZWvHBKoLtrz4s8hwMvvEf3jbp9PrS7+n8Fu6DZyLvpOLg8Fm34Ot2FXzpPTZM700TSOrzFILx0OrK80hqGO/+GQbziFlg4c/+yOVcVxTqgYXu8YYJ1u20VLz0T9Qm80GnJO2ODsbznx0288mMoPLXPELtaW+U7Qz12PO3of7wU41o9FR9dvKRYDD2Ou1I8r4CSOw7EHDwAOk+6qILcvAk3hzxTzdC8aqKou9TOGbxWYCQ7rvI9vOsshzy1gbM6YR6hPPAOLjuRvIk7upHxObbRU7xUvUo8hu4hO/xiUjz84dY8QjLiPH6+H7p0G8c813mcu6pyyjxsfrU8Ks4dPIbtibojSKQ8yUcCvNokOT03Io88GyV9PFP2ubznGrg7hO4zvQtgUTvigmI7WS0zu9EtsLv4EIS8H1szvNcjQDye6uG70lWPPIegAr3ryB88ZigOPDKo1TyU19u8+hIYO+jWwry4LKc8f5pFvdio1rui9ZE8C9KqvAcXmLz7QF08QrG1uiE7ATzezHA8MFHgvNA9G73Q1Qu9s92EvNKU5DuwMAI9pfUAvevPU7yEV1Q772J9vKxyuLqu/Ck87VGNvI5pyTzRexY95W0TPZXgtbp8Hs68DLW5PNitOLwdTZm8aBSHu1g5krxYrsa7SLOBOz9IaDzp0t07Dao1vKDPpjuthAO9j8iVvLQuGjxcMC48YXlNvBhXb7wGOpi8XIDqPCYOrjyGOzE9VhdqPJFc0LwN+pS88gynPIxdQLyvXBE9o4YEO+/2JrzbWYe8sMzfu/47Cj0TxBe9fur6Ow4bUrtflqS71CwqPRE5pLw5Iz89Q+gLO4ohmjzET3I83m4OvTS39LxVnEa89JRKPBZ/lDziBia8o3nzO0k+u7sZEao8eMVUPAVDaDx8MRG9rAwIvTDw77tnV6u83RblvGV4DL2v8YS8e+uAvFGgGDy7dEs8xbQOvFp1e7zT+Ay8wmn7PCZg+bwnK2O7BnyXvO9jpDyyPzm7+7yGvMTG0DxqkbS681AGvITY8rxpgMk8fBEQvQfMgbx2zh48rjP1vLq/cbxNvqE8HjuzPDmtDrzVk9i8KbmhPF6XPDxvcfI8BZErPD93xDz1ARm9ssnJO9xQzjySlXi84Zr4PHvQCj1hGZU8WGgPPd/irTv0jdc8XzKQu8H5ITuW8Sa8gkCfPEOgNLkIGKU8U0JNvGUAJzzc73e830QxvI40hryBYPK87ccYO6jpNDy6px88k7xrPJvCjDxbZxe9+KxivIpznjzHQ5w8cmOrvA+827wH35a7Q6ZYPKTyxbpYLKq88lXmvBxcDLy6uuG8/Pf3vFiNCD0xoLE8kyWjO7W2orjkXew6PHmNvNRvizyRvEi8ppiaPOy9CTwvrbs7VtUjuwTcL7zvTgk9gaXtO5/CJ7z54Sg84MwEPb+llbsuxmm8a01AvIAe9Lx3KFI8P7gHOtEPjbxAImm8qk0QOhQBsLynmOy7MOWmuYzWKj361u07HF4Wu2II1jz1Mbq8iZLdPEGuT7zePS69DT8KPJvQiTwbqGY7HQWkvEandrwT1Bq7ou3Bu70IQLy6Gp87FZrZvNr6sjwQ2gy96ZhQvOqNsTyCA/a851ZqO/aREj1UTRO8rGAJu8WHpLsylSG7yftZPM3erjtNjyE9uBBgO41uozx2w2k8+JgXPFGRErzniq26vlAfvA/fTDtxHwm9Z9hJvHj86jwVaeq7Geh5uqM0t7t7Vs+7GDVDPRM3fj2OTQy8/g/SvOiLILyWZdC8dkPSPA== + index: 2 + object: embedding + - embedding: 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 + index: 3 + object: embedding + - embedding: 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 + index: 4 + object: embedding model: qwen3-embedding:4b object: list usage: - prompt_tokens: 10 - total_tokens: 10 + prompt_tokens: 858 + total_tokens: 858 status: code: 200 message: OK diff --git a/tests/cassettes/test_chunk/test_chunk_search_returns_empty_for_blank_query.yaml b/tests/cassettes/test_chunk/test_chunk_search_returns_empty_for_blank_query.yaml new file mode 100644 index 00000000..2c719326 --- /dev/null +++ b/tests/cassettes/test_chunk/test_chunk_search_returns_empty_for_blank_query.yaml @@ -0,0 +1,82 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '102' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - Searchable body about elections. + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 7 + total_tokens: 7 + status: + code: 200 + message: OK +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '79' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - elections + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 3 + total_tokens: 3 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_client/test_import_documents_schedules_vacuum_per_config[False].yaml b/tests/cassettes/test_client/test_import_documents_schedules_vacuum_per_config[False].yaml new file mode 100644 index 00000000..d5ea4a7f --- /dev/null +++ b/tests/cassettes/test_client/test_import_documents_schedules_vacuum_per_config[False].yaml @@ -0,0 +1,42 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '90' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - Batch imported body. + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 06REucjsDL313Mm6HszwvNORB7q45uM8IXsFPRlcorw8Cwc8xM4IvX3p37yOPRw9gN0dOa0zQL0ZG+A81TlBvV0yZjxAGSq9sEJlPIykIrpmHZ28zoKRPO+k9Tx7dy29fQdDvfpPfbw2mcK8w6o0vRcZpjo2oCQ9zGoqvPnAf72Fi9m8dTs0vVN7bjsaQIO8Mv4vOzpeZ7ywmpg6lMinPAbwSzw0RNW8LDwouocsHbtVKg485LXGuXwA1Dsg3Qi9xbq4vDVWi7wrvC07z4ZRPK/Cl7ySpq28negBPKC6fbyQlEK8qECBuhFnLb3B4Yo804qcO79bVbxDFLq7w2KVvKjttbvXIJ68LJ11vBTqu7xFMk88eMTCO90dLT1lwno8zdouPCGNKTw4UhY8qEz2vE7SNbtQh5M88FcDvF36GDwYkwo97D/hu3Hijrs2sAw8uUq7POlRUbyJN8i8urewPDbdH71E3Ky78J20O68Xv7yFqHS8Kk8+PavxurqcyTk8gspqPLSFbrzOMNG7I88EPBzJKrzEtLA7YvWou4LQi7uMJiU9PAa7vPoUqbzv41w7v4QRO/hnvzv075O83FyFOxcOvbtw+bw7e06Kuw5SbzzxKga8gBMmPGusBz2ggQo9qD/yNmPlAzzX9wO6XYEbvErLQLwcHk881ThNPLen0rzzzSg8aK2VPNkmArw+u827KWOEPEHlcTxhOc+8VZ9XPKuvGbxTz7y8TOiaPGU4XbwO9CU8PkLkuwmGLzx46qw8hFvnu2Ennjw57Hy8lwNkvJVwX7vCdBc84MicPLCFfbwH3Dy8pEMKuw+jfLsifQo9fQDUOhX7Bj0YFFC7P03lu1N0HLxx+Ac7HviKu6tmjzz3C2U7Q/q7Oq3PILxZrEE8sfaDu3c1FzoHrz26+pJRvAbl5rstqom8hcQCvaS55Dvvnci7Z6p8Ox4nZ7zx7rg8e/Hru19rHD0EYD69kRH4u02xPzxo4oE8eQemvMPrqDzljog7oVd0PEMwx7sddtQ85BTHu2FSBDzD32K7Wh4WvCMYfbz7R9A8qLStvHOTuTv0NAm60zxVvBq8sDspFp67+RZiOwdMh7x0Yak5Od1tu3jIDjyaUEy8gv9uOwIBADxdvbK8MJRwvUpcgDuAfS08xTPjvNd+BLw8CdM8slVnPXn7CTf/HLU7DOAPvPszLbsCL9W8gon2Oz47bTxuKsi7QvlEPKxT1rl2asw8bKcFPUrAjLthWjA6R5tdPEPyYzxkVtw6znj1PHDTFrtu71q9He9rPB6OJbyVYDe8gh9aOwOzeDvlBca8PsKRu2yzs7uJUY04MoGAvP70gbscGq+5n4G0O8iWgLvbAKK8jhBtvHFWGLwpKTM8oBTbvB+K8bwXtVe7sEwqPAwRpTsTEyk6oQqzPJhGQ7wt2y+8x6XuurWkzru215M7aFacO5TAirwNWOM7A9/Mu8kQT7xDH4C809wvOwxg5Dsw7uk8MayYO3jwarys0Mc7EzkDvfl2XTsZaKM7cKYlPZgvkTzJEbu7PghUO22QsDtebRo9LP1MOt/2tjwe19O8SOAbvG9Avrzl2AE8i1tvu2n98bxL63S8HFzZO9O0trponw67wecaPPiuyDpdAJI7Ge22vOJ56jzDZo+8J6/vPCs/b7lHM4+8i/k9O3I53zuSONS7bkYsPIfXh7zvOrA6SSPYu5KqpbyG4mI8Y/SgPB+4n7w7KNq7fZDYvJPo8TtZjD88cxn+PDFCdb3v89A8tY9wvRb0uTyFWYu7ypfgu2vPk7tNgci7vvIju859jzxF2CA7r9I8vJcYiLqMege8VJg7PD4rzjwLj7E7WmM3vBS0ED1SsCA8yWrCu7y9cjzxwK+61NWmvKMAHL3u5hi82AQLPYKL7zySQci86lZ0Oz0g17vDlE+8MFe3OnMyy7o+boW7R1tgu4DwH71DP3Y3wr3AO+223zzlY4W6BNeSvLUs9jwTkQW8c9CKOwU3vTzeezm8GvZJPE0BmDwvXG26/qqKOpuBDDxfsZM8cA/HvLOVrrwLpbA8MIlIO4kgdbwbicG8VzzHPKVKBr3uj0Q89q+DPLKR27xqkSK8CfE1PAFWybuE3fU8tod8OxjPjDxn2cA8q9CZvIi+pTxA+s08yTRDPH8vdDxAtA66oRl1u430MDuBNeQ8nQ0kPFywnTx2boA8mf8SvZ6x5TtZNB67sIRZvYfosjuczV08uq+DvCmYfrxD7o08175nu9UKyLw4C2A7BC/NOrDverwrK288uJAmPTYeAD0Oq4Q8BDN/PGPOBDyK3nq8i75avG2Ikjz922C8wwWyPMnmYLoJTd88rc3VuwtEbbxPmAA8c09TOVK9Lzygcic9eVd7ve3yibytxUg8p93NPH+SpTxeV/q8cEhFvds+DzwaU2g8pC+0u9a5xjwfHLW6LNgVPBTzHb1cImi8c2awvI2dcr1sT+o7zEj0vOX+Yrzcdau7JcRxu6ZhB7x5Wc488ZwEPRKG67y0dlo8PerSOxL0P7zS78U61XS+u430uzu5b088/gZVujRrM7wPRT48R4VgPYt4ybuWydo8JKIePGdg57sVIyM9lIRTPbmiLjwVm6Y69pP/vFyxEzwyZhk7yLcyvNve2byt3hm8pkB4vN2h3DwPXzC9DKJMvAmNKryWMsG7LEyaONYlRLyy8m48rMQRvFwJhrpuvy67lfyNu0ms47tJaIG8ALi3Os0X7rsrPpM6+M99vdPQsrsAXaW8Si50PNkowLyEuAY8usFLPG3ZN70Esg09lrbYPEDcnrs5+Tw8Et7jOyIQ8TxbFNq7M5IYPP9WyTsHcKe7QZ4xPFUIqLowAFW6DX0UvcfShbwNwL+8nJK9PMRrzjtc3AE9ykyEPHemuDxh8jY7kiwHuuqmw7yPOl681Uk8vKWL7Dy5dha9psisu+SR8jwviCe7Cz/KO7Ij8ruhnju88mddPIEWjTz7LbQ8Px5pPI0S6jw/lr279EC4OxtohDwRE0w8cTkSPX1VsLxCHoi8vGxvPNyWWrs/Zbc8H9frN695HT2LVcs8GBu2vLLmDDycDdw8OHbHOSaHkzxeOJE805ENvFYxtLpbqFk8bsN5PCESaTkP6Og7GZXbvDW1gjwETqq8sEqRO/VrVbxgPKe8QPoJPN6ViDp1FOA85ytDPBjjCbyvigs9njMdvU5oEDuJJ/I7mbwJPCwctjv3RPS7Urj9u6B/vLylhn07ILRkPLFgFzvAuJ28jPx8PH6LMTy82Zk8X3OUu2BneTsgTMG6QePROjur4bteVGG8ZLlHu8tOcTy0cnq8jwyyvBM2vjvpwge8nB6KO0VUC702k5Y8kEtcvK3ILr3Hcui8LWicvAvnjTwGdmA8MBKivNNg/zw65Ry9Cd9evf2uLjz6SDM8ZoQsPDceZTz0BxY86Ok/PcBl7zxiL2o9EeDou+jBQL1ac8a7wAySvH3NfTz45T68DKaEvM4YjLsrzpO8m4xCPFachLwKlgc8VSB4OxHI0jxY/kq7k+ppvB3a0LwDX/g8+7sGPSyd5LyG1Sw8FN7nvKqmLr32fH68ZcQKOzlbZLx8eLQ8gx23PNayLbx7Vho8ONigvAMGCTw/UmM7MCySvDjjqDxLiDW7GEdLPK6mnLmMQKk7xtNBvZj+Jj0FxNs6qwb6O5zFhTwtyyk8/m6mOkoolzzotBo8EmJ8PHHhLj2p1vG7tGRcPOBv6rwL1ZG7k3u2vKgS57yFQ+o8YHD+OxBDZrxsnAO8zyMyvPRvNDzvkQm7vGRduhHZCbt539g84FaRvAINsTtieme8ckBnuw2lS7wqSkS9TLz3usQyZDsXH5o61+uXPG4/kjrWq8A6o2I3PY3EMbzACQO7BHxlvNH/gTxo74K84RPcPDxXvzy2KYM898jPPOmzrDzsQQW91ZHHvJbqGLxiZ6Q7HCTwPOKUH7t/xzk8J1kOu/p7RrylGLE8gWyDu2FDEL1+hfu80kbHvE7FDLzFF+46MEgZPDBYx7yCpe88N8ovvbE9P72sfio7TpG7vD6ysjzX9Ki81y7Su8xe9LsV+s68qWdDvGISELxPZbu8Iny4PCRElzyzvFc7VfNOPL6xuTweJYm8phijPJk72jxNALM8gRuruRBpFLw6wzM8qcW1O/JgDD3t5GI8Nr/Iuz3rHr3s0ge6jdlfvIhu+7utLBY8iy/fvF+BCb15GYA8NC7fu/gmZLx8z4i7lzSBOWxtmjyWlAO9+kXou3Ec2ztKCkW8UKiBvEgrt7s2woe8FjvEu4j2w7y5hny8WnLXPP9rZTwVmzk8qLi2vIKTrztMVvQ8DDFMPZAl7rxniEC7K2AMO6joBb2nJPK8CEPCPDhnIrz8Uuo7KCGOPKi3ILmfGty81WQYPfVnC71v+PI8IW9ePP3x0jz93C67WIgXO+aTCT1Ey9O7z0HUu7jyuzwyCtu7dE52u9U1p7wQKZK8bSqQveAg6LvrRIK8iUEKPEKDsbtUtp87djEPvEvERDyapw88k54xvJ1aYzz1c8k7BlFMvH2JwTzzVRw9bHdNPAtitzsY/dK8N3OtPJ2utbsckUq9HDoAvMpUjzzPuds891m1vMXlvLylRTM8/IZyPCq+zzuHYrC7R7zAvEeoqDyLxcW8h1XBPLtigjq8wWK8kPWRPBy9m7xA9bQ8Yu0/vMdHCruU14S8EOYnvDCn+zvM0oo7+8n4PE6TFT1085I8n2tsPKwUSLwYUQM7SlMivFt4RTu4Vx28ehFLPP3VNTwMfN48e+B4PAU2qTt2yBG8OmSEvFAcAD02QmG8F059vAiJSz0T9yi7atC7vOwRUj1kZRC6pfUOPBSoRD3XAPO8+aq6vEvC1ztj0DK88MHxumCoeDvhr8a8Kt9RPKgKgbx+sTM99skZvYY0Er2QiMc8HKd4PIR9C72FBjc8SxEOO4Grs7xa3iu9JXyfvBzmIbz1vvu7sI5APB8VrrzIeYS7wx+3uYFenLxdO4g8KHCDPNm27TsYcjU7FC6XO8wtH7yV2bG8xxWevPuiSj3/jio8XVfUu2wi1rysNYc8Kae5O/HTzbsjUdk8N+mDPB821rxm7kc8p3RnPJmuOTwkN2o8RqnYuwtdIrugSaO7s+AgvRkFqzxmZhy8DEG3PJc1uzv2T1S8OGRUPG0cPTu7IUM8tDY1vFuXtjwKNv474v4uuv9C1juKbZa8jkz2Oyg2pDwCrwU8L8VvPKOAizv7r/y8LOJaPGHJmrtASIW8DmmTvP+XbLsxcYS8ODTzu33K6Tzf2RG95IKFvEWFnzzqdhg6LmeuOp5T7rwjYoc8VNFzvCiDLjl0Yj89vNPiPJ9uBL0cfWS7ImAxOzALhLuBwge9CTjUvJDMFD0lTd678Wf5PFPuVbwqyxO9+HPevPNhCbxJHqK8NcfyNyjDvjy/+oI73xH0PNv5KbzE+oy8eDh+PFfmQ7sXut08Vfi1uzpPXLzsxpC7oS2OuRuLbTzBYxq7a/+aPJUnjDuE+9G83/j5OrV6aryMyx488k8uvQ8zkTsFfk08MK/rvHBcp7zaO6i8IJGuuxcGILyQlfY7NHiXPEVWajxrRUU8V5n3u0/3FTs0pfi8pIcLPAOG/jgfOOe8fBisPFRTTbzk7pM8Ch7euu0jirqIPSs9qMlUPUyLE7zvSRy6hGeOupIsnLwhe/i8kzavvHP4BjsCn2M8MS9PO7DVAjzyLw29/aLbPMmI9TyNRa072MEZPdSpSroPxto5UAx5vJZ/B7wx8Ba9+qj+vLWXuzpj6bq8f80DvRC6mjxk6wK90r+pPNYgIbxpKTE8HjsBPfIlhDzx/oO7tJj6O17LQTwRP5w888W/u+kZvzu1pXu9zTe9vIddpzwWDMI78wyovM5CNDxXbNY8HXEku+8loLyT6XC7DlUmPelwxLtRwiE9nVE2vJBc5Dr/csC817xcPIaalDzb/pC86kfuu1d5Sznsnq68haOqvFURGbz61mg7E37UOprvgDwuIle7NWJbvLuP2jrMDoS8TJ3HPHTkvzzrByS92BZFPBTSkLqPLTS93923u6R2+zw9C9c8IRLzOxaumTzNsAi8yMBpvGzAUTq2JgS8P0WsvHI+jTs0EC09skKRu32EI7yFhBG8UUqJOwEZdLsnV0g8ozGDvGNznLstMzA8Y94RPaEQ0zpgzr06RdcMvL0RODzlKP45D6m3uz2g5rp6HZ281BJTvB29tbw/ozw7hcjpuuPqn7zBwGG8wwfLu7bFwbxMkJw8RcD8um7YdTxa/Hg8RwKePBoLHb2aoAc9w2PSvBpP37z+GMu6e5guOz6WTrx2JJC7jrKbPAXZGzwz/+Y82/a9PEXypzxOVuY8IeVOPHG/JbuKiyW9+GQJNpBpkbykK5o8Q7esu6WNoLxzLXS8DpdYvDK+I7xhPOC7VNFuOrSCNLwID4S75JyXuhouiDyR/lW8XcwIPQzyMrzmIIO8V6t9vDFI+LpjOAy9vVUPvQQLLzxn3XK8t3gMPGPoizxMhV28q+9rvOahsjxAyMk7rLYuvGlX3bxaZsY8XggNPV2BYjxUfGY8tSs6PBWLyjzL4Uo88IbmO5GrA71hDYo8x3htvJ5ETb0JNGM7/HctPGunQTyke2I8kgKUPGSvRbw+ezo9xmYpPBuqNzyJIiY8CpIHvBdJx7woyPK8frmIPObrMby5kx+7amvyPOAp/rtGEQw9Zuv9PPJ0WDt+/wE9djOvvL6CUzyfzwi8TIfuvCHPIDx0eGW6BCd5PFR7mbwXJ1k8YkzmPPlLIrxGBkY921q9vJ1KNj3GPLC7mUufvJS1XzkGmPq8mM/svB8rPrxrcwS9zn6rPMWThzvexwm8g8wAuxPxETvTx2y8+10mPIgGlrwyIR69RN1OOyJB0bx9Uyu9sDnmPLF6zLzF9Dg8pQ/LPDbIlLzv6HY8hQw2vMwdHDzXn708eg/VPBe7CL2mag69FYUxvZQd5zxrIyI70V0zPCpwcjqy0ag8s7AkvSwG7DopnPM6h5YFu882CLwvEuO83949vfElLTwIVtK86U+ZvH+FYjvgxxC9zDiMvKiGZjwouqO6yhBGPSsw37p+XYA89GIbvEc1Izy7qqQ8hOQZPClmELjqM1q8IdgkvJtG6zyKe5c8YZItPe1/ILuHlRa8J095vCGcg7yQ+A48kNqyO7uhODyv2JO8Wonou1hpiDxkrHa7pbY+PExk9ruJCA+9UuSsPJmisTzDxpA7ITxruk/qkTzqB7m7cjCxPJ3vSzukxUi8jk1KvJ0o0LsT7gs8n1gBPLTAyTztqv27mnheu18LuTueWGQ8hPyxPHXTZLuh0pK8zD5GPfQHGjtL+JC8rLYVvWQHg7zp/Ta92T3lPMNOo7tePfU81bOtu32CTj0tUPA6oBgavdObQDy5gZY4crctu8e/Djw+Ai08NBIovbmPhrsMfga8O9uFOiIeTjwgqpe88jxVOz1E0DwxAQ05Hhu/Oy3+Q705z2i8aDkaveXKK70Xqei8FXLhu3arajumaqC8+sdaPEy4kzqWqBa8JNEoPN3qmbru/ga9dtzLu64lo7yzXMg8CO8wPD+wszwKQfK8GsMRPGGAfbwjeKQ76oibvNPUNz0OQCU85xhXvKxgX7q2vt07/2SRvFnuGDu7sKK8YLkYvExjpryzZXw8rmWWPOG2Oj31Yve7sHO5vN87tbws/iw8D7uTvHEXAb0afZu8TIMuO4/aqLu3hhi8JRqSOxfLp7tBxMw6b6SHPL5d0LvOIpO7YHcWPduqLbySW2y8U/wgPOjeVDvppsg86OzOOzRzGb2DgqS7l4QGPb4f07zKvx69M/TPvGb/crz5V/C8fTAGvYjL5js2Wjs7QjH+O80n0DyGjsA8CbhqPP6QPbxBOxO8F3ebueGj8LxlSc47EiUou3G5EzzmShS8JCLCvCZXlLydu/m8kZmDuvuaATlgkT07GwGAPNRN7DwwpFI85UESPWj5A7w7BDS7qKUaOxX1EjyXWfq6QBIJvROmkLmhZRw8qEtiPDHte7xzQNo5MVIKvEtY0Lqav5A82VmPvOkwDDxksZa8YS6nPDMuljyiJY48cOGbPKc2LLxBL3U8cLT+vB1KTDtIbau8mdAfO0EElzxJfWk8neHrPKDn3LxvQ7S6ud2lPEdCRru6SK081pAbvMyj2DryLOA87QyVu0qZpzvfvjS7FJjku6jTsTvL19i8df43PLCM1DxWUMY8pS3Bu2IAmDzvAfE8fn2BuzgUrDtfXSo8M7BDvJY1Vj2k2NM8SPIKvFyj5DzcDCy8Z2CkvJ4Ljjy3kxu8iL0Zu8R5m7zZxfS7pCFaORKOAD1qa/23ZCTKvCkOxzyY2Ue8oDayvF8ajzz9GcC5yUabPKNFcrq1htw8j5WGOyZLOD3c5As8xvA6uzDEaTxd2xM8cnAqPIX8Az3onwC84cb1u31e0DzWYci863oUuVOqijtKHxk9mnG9PJB+TTtp3yQ8TRjGvLCp4jz7L088hRbTPCsAxrqOf9Y5dQwgu1gHdjxblkW7FUYzPVuo3rzDjSu8aH2ePGe+lTzlnO+7DPx2u6pG0zw4d5a7uF+gvFmPu7xcfsy8sWtZPGWwk7txqr+8E/jMPLT10DuF9ii90T76O6K5sjwngJQ6WXWJPKScqrsCxhs8feoivDJ5y7rKWEo8rrKFvKkp37vZ0s67CogMPRUtpzyXOQC966iqOnM4arx8u8m7aMTku8a7IjyDO+I8yC6Au2CqBz2LuyO7dyy2vBxDGLwbbS+9atPrvB9irrxG3uW8+FVZPOBnnzy/Q8W6v/P4u6dvHr2TRuK752qNvB3UQL3UohA8+LMdPAnpEbxdvbE7N06/vEB2jDxPhs+78YVuPMB3mzwlMyq9DfaRPFjXj7lHgxu8tpB8PMjZED1plEE9pbsGvHvHnTzcOXa7CCUyvEUvFb1QF9w7GmurPK74bbxMGjY7VO+FvG6b7LyCs6M8NMZ9PEXOS7zqQ/e7j4IkOlO57Tu1hls8mOcsvIEuvTwBAXw8D0tIPBjQpTyorh69u6hSPHtEQjzkXow7JhfOOtN6m7y5rQS95BbXPCRMQTsLNqY8luKsuudSpDyWLIC950SjvGpcg7yvmGe4iOdovLnGBjzqota8SQ6Jumy25Dt/Lhc8DtmcOnIHALwmALe87aJKOmN5hzy/R727LeKnvA2Psrx+Ba0898Q6PPnwEbuG6So9pP6suRtuOTzce0480wK6PBVR/zz/MR+8mNqiPAfnnTy6buq8e28WPFvTBzwaXoW8iNPCPEmUwrujR2u8x5c3vBUdnjtfIDi7tT3CvNI/yzzFbuo8xuq/uwB01rz3DxO8dTaTvCb8arzuOtQ7qIkiPCokZLubQr47RmRoOeRjmLtSkIK45JyZuw1abzy9PBA9ebyxvFyeojxkJBa8E3wTPXMLjryIoSM8NwjCOwYcXDo0tUA8kWXuPKaQEjxbuYO8jMUDuyUVMzzKMUq88fkFvFUc3bu0sR29a3invFOOqTtJhGC89GIOPb0xvTs6gwm8m+b9PIJ4arwFNN27zFXTPNnR+jzrppK8cPLXOmxXED33Ufi7MZhKO/MBaDuouhy8sREuvebO57zltgk821EcvUCqdjy2YsQ7a/cPPFP4ULxnana65NCHvA1cvzyr3pM8sMFIPAPXCzzg4fG8bFI0PVfVabyVOhw7OigXO48Qljs5L8+8Nz0AveFS6rwBDZo8uph8O1koCb1c9qk8mtqxPDmFkbyej424TXawuwxoJD1zFkK9fNiZO/oe8jo+vEq9iKiBvNCxW7yKKS+7nDpnvNK4qjx3/C28qP29u87Q3TwQYB88htvTvPV2GT1MOzW8rnwBvfhHYTyfjY48c7CJPFxpsDzcjPk7giFvvK8TW7yiqkw8WP+0uhMzarxxyOK7khPjvHbt3rsm6bA8MzyCPBJNFj0LhB673UA+vOzxsTsXmWq6iVY3veKhzbzG3R69bLe3O7/82zvKane7647SPEHZrzxkBdY7JNrqOg99ZLxcOKY8TTb0PFVZ2boH06e8vY33OYI7nTwQ2lw8DgwBvStUxzwA3568FQrwu6TuA7wsynI7S6B2PMbR4bwAN9A8RaA3uhRpbDzoNIc8ty3CPD1Ghbca5PO7yQKWvGtwLzxF3B48Yo2IOx6z2bwTCSQ6Yp2tvMI5tTztKZc7ZUqSPNWiLjyI+bw8tDFIPC8nsDzjdLi8s6KHPR+bsrwF5cO8eVb6PJrTcjw7yps8GFfnvH88gTyoVwA8W4KoPFIDDbo0Frk8j+vLuwu7rzws+IW8atRgOlbfBL14U2s8o061O7OO4zxVBqu8Js8DPekK9rtkdao7T76KPEaqzLsnud88SqNhO3ZnfDhhDKe8FDcAu+C6DDzi58w67pjAu2R2qLvOcsO8JwPNO2cooDwuK927xAKmvGrYUrx7MHu8fccpuwOXDLwDSA86DH4hvaYC8LtAM/y8oeRjO/8V4rtL1be8aBwOPZbACr3LEwi8o9mWvPufIL1CREA8Zkv9PGUOkDpqya68krwPvaEwtryCxEO8VxOwO68yqTuiXzE8xrCQunEHebuDIsU7Zavqujk7pLsV3kW8FCXxPIedw7wUuZ07jEHGvBoxqTow/Vo8uyneOzBJ5zxNCBE9+2NavJW1rzyMORW81ChtPC8lpjz/PiS7SNX0O/RqO7wA7+08MYaSvE2uiLttO+K8ENZeu52q77pcERA8TV6bONZ80LvOgs68vy88PEkoojtsw468QPIiuzQu07xfpOw4IyNBPVZ+7LxFJYI7WxQguzQd/rpEueK8yrsHvVGdVDsnhT28U7rPPGZA4rzyBzc9NTR3vLqbkTuXbKq8DoI2PJvFET2n9FE82UhqPH0cY7zL+Ye8rn63POmhwTm+KoK8ZYjBugy8pDyiY4S8fA3wPM7yRTwERQ28RO49vDl3RLw16F+8AtcZu2SuszzYDMo7cgYgPG+lYDzHTAk6mBapuk4YADwJTyK8w293vCqCyTyVKZ0804TpO7u6uDnVMjc8RM4NPCN/Jbxd5628yTQGPVTS7ryNT+K84RCQvcl0GLzcoX28JDcoupUDAjypuLO8C9P1O0D/Yryki9w6DHLQur++7DuXWpw7EMmDu1JmBr0HxUU8lBnDO8IOwDwMwk47f3qzO009Jz2HcW686M6EOy3C07zSFmY8WCVhvBcgJDxQzW+8/YglPDyMsLpFs1M6gs76OwA5PL1DTvI7JTWRO7NdSzz6QdS8ejy9u3UgsTxPuaE8aoa0vBBCHjxatUg82OuGvG1PEDx9b7i7VW88vRIO6rwEd6s8crrgPDZM0rwPqCc8aIo2u6pugzziHPa8AT63vPlaqrx70+27W3o/vAiHgru++gS9yaSoO9O+bTxVfTK8sUasvKEXAbt5O828bhAAPZ27ojxeCl08BXkDPLfrZzyNTAq8YYYhPOaGMTyalIO8LHiDO3X+6Lyb0xs7OfUnOgEHhbx0CQu8ZZXuOzOayrvPTIW8KCyMPOcnqTvrn3g866nsOgqdAjlfFpm80ywnvY9x47zsu1Q8tAPbOs9DkbsKNbM8pbyjPHbFujomYCA8Slq1vNOu77wuKrM8ZZdlvCoZhTpqgWA7u39tPL+RR7xMy7y8/bUUvA9nuruTHHs8Z9OCvE8fPz3GMzK8z8O2PGgksDvZEDo832f0vB59PLxmTD08I28JPThMt7yct9y8xnSRvGASyLxKhpE808RVvGwKubwKAgY9YqGePEASG7tnncG8yhVKPB3FgzygzZm7toG4PIeOS7tZ2/w72IVHPHsdKDz53Vw9SN1SPL5wqTog0DQ8NhwgvGr3T7zzlAk91GOsOrmOoLv15uK8z/EzPYvwzjxONTm5zjZdPPPgPL2qD6474z72PL6hFr3LoMk8SuOOPJULQLsd1QC7qtkdvEVZgDwriEK8B6XSvJja4bwNYhG82eGGPA6iLL0c1uk71agevdW4HL2aLgw7wsEFPF8u/LtoiCQ8R3jLvMyMBbypreo72ViEu3bstzzBY0K7HH1yPBaNd7zOC4I6rAIEvOH3vzyeWYm7GXcOO+FYijw8oNi8sqx/vDMCUbwqRdy8YqWMvG59QLsu0XO7N9x0PBAKejy99xS99gIQu4Ieyzz1R1+8CWI5PFvHhrya2vO7RcaYvIAEGbx12y29u9qXvIm7H7xJWRm8dzuquXNsB73/QxI9nMNIPInyIT2tPKO7LyqzPDtUoDyANRo82xeSO07JFrwTkgW9rkckvHtdszxoLVK9k4wAPC9CMzu73hW9hBW8vGwgJb0OoWA96w+jvI7J2Dsn+Ny7GZNAPCZohryh+xM76XU2u6WWqTyScq08+kmtvBOXsbuW/5Y81Z/luTizpTw6YfW8vUb+vIiNHT0h4fo8kKmBu5ovJbxmyye8n8w4O07Bu7tYw4o8ubkHPKVzCj2KwJ27PqmMOiTCIDxh9PG7S8FCvHhlr7qfcNE837kBvGvecb0colm7mbiyvOyFj7wVC868Hai4PFYSQTweQRC8T/2QvIwahbwCcQK9mX3dvMoOjzxnF4U7XrqwvNM+tDyOBBu8DkifOuO4Qz0h0Ug9VSkqOxMUzLuFHpQ6z8klPFbSl7xUas68J2wnPCSg8LvBfAK8seQsvLvy3Luplym82SPLO8FcgrtsCcY6iW48PObti7xOKYC7xsnDPLLNlryrgF69ixT0vN6YvDyB7Li8BIo2vCV/WjtqJf48sMrPuzFEjDwSHE4767m7u4v9VrvZRJi8hpMWOxDGD73ZjnQ8BQbhu2mJtjxgOxU85O6VOtFWpbpMti68QwqVvM7KmbyNNqk7jRKpvGj+8Dt4Nes8GIF9vP7tHby6h+a70nRdvMaFTz3Sp4I8dHKZu8vR57w5Dai8xDK+uwo4KLw0o4Q8fk+evN1M4bx1/Qu9RDK6OwIVGL0Clb46FaIKu/ngTTvmNsA8Nz2mvTYZNjwp4j+8s2hxPKqb/7ztWY08Et2UO0feNDtrtUq8JpyKvLURkTzoERa9YcCdPFV1Dbxr8MQ8TNJavKAtgjy/8xG8EvGwu8xfFbug65Q8YMIduzSKRrtnBhU8e3YVu2M9hjqnnYK8T9MOvFJ5HLzhUw289VWNO4+Q47vd6N48EQR3vOZ2gDx0q+Q7hJpHOyWxszyEy508QdSmvAyfuzxVw8I8da6hvAOF/zweOKi7swexuvtEWbtqCK47H8QdPEJ2KjvOPho8tckovbEACL0OH7C8QxvwO0zZmDxH84o7Qt8xvAkkrjwG+Bg8BdFFPHYOgTs5Qgm8HC4xuyrpcrvKCPM6B+SGO3FGNDu5DIe8cI8mPQQWZjzyORI8RzUWvOjjDTxihfQ8L3PQPOiMFj0i8cM72UCgvDReDzzvMOQ7r86AOyZTw7yncES7eoLVvGPx8rw+Bwo82rIjvCT6sLzMhh+8BBzWvNsLzLwEFyG9T9YVvWbDfrw9P6s6YF7RO3fu5LwKhMO782+GPGkJVzuRxSa8VRIyPBVakLs4sS88HzcavfizlryBaVw7S2KtOz5DjrtaBDY8LYUyPN2qlry7/q28bCgOPGhhnTzD4BW9TYTdvKzIMTxcqI67949evGGpczxXxSk7jP7mvNNctbw2Bz68I4EKPA== + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 5 + total_tokens: 5 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/cassettes/test_client/test_import_documents_schedules_vacuum_when_enabled.yaml b/tests/cassettes/test_client/test_import_documents_schedules_vacuum_per_config[True].yaml similarity index 100% rename from tests/cassettes/test_client/test_import_documents_schedules_vacuum_when_enabled.yaml rename to tests/cassettes/test_client/test_import_documents_schedules_vacuum_per_config[True].yaml diff --git a/tests/cassettes/test_rebuild/test_flush_rebuild_batch_is_a_noop_without_documents.yaml b/tests/cassettes/test_rebuild/test_flush_rebuild_batch_is_a_noop_without_documents.yaml new file mode 100644 index 00000000..624bafb2 --- /dev/null +++ b/tests/cassettes/test_rebuild/test_flush_rebuild_batch_is_a_noop_without_documents.yaml @@ -0,0 +1,42 @@ +interactions: +- request: + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '77' + content-type: + - application/json + host: + - localhost:11434 + method: POST + parsed_body: + encoding_format: base64 + input: + - keep me + model: qwen3-embedding:4b + uri: http://localhost:11434/v1/embeddings + response: + headers: + content-type: + - application/json + transfer-encoding: + - chunked + parsed_body: + data: + - embedding: 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 + index: 0 + object: embedding + model: qwen3-embedding:4b + object: list + usage: + prompt_tokens: 3 + total_tokens: 3 + status: + code: 200 + message: OK +version: 1 diff --git a/tests/ingester/test_fs_source.py b/tests/ingester/test_fs_source.py index 105b698b..55b4fc17 100644 --- a/tests/ingester/test_fs_source.py +++ b/tests/ingester/test_fs_source.py @@ -338,6 +338,11 @@ async def test_fetch_rejects_foreign_scheme(tmp_path): so the unsupported-scheme path must be handled there too.""" src = FSSource(root=tmp_path, supported_extensions=[".md"], source_id="local") + # A same-named file under the root exists, so a scheme-blind implementation + # would happily resolve it — None/raise here really is the scheme check. + (tmp_path / "key.md").write_text("local copy") + assert await src.head((tmp_path / "key.md").as_uri()) is not None + with pytest.raises(UnsupportedSourceError): await src.fetch("s3://bucket/key.md") diff --git a/tests/ingester/test_webdav_source.py b/tests/ingester/test_webdav_source.py index 1da7e450..8659c017 100644 --- a/tests/ingester/test_webdav_source.py +++ b/tests/ingester/test_webdav_source.py @@ -713,19 +713,16 @@ async def test_head_returns_none_for_empty_multistatus(): assert await src.head("https://nc.example.com/dav/a.md") is None -@pytest.mark.asyncio -async def test_entry_with_status_but_no_prop_has_no_revision(): - """A 200 propstat carrying no still yields an entry, without a revision.""" +def test_entry_with_status_but_no_prop_has_no_revision(): + """A 200 propstat carrying no still yields an entry, without a + revision — distinct from the malformed bodies that yield no entry at all.""" + from haiku.rag.ingester.sources.webdav import _parse_multistatus - def handler(request: httpx.Request) -> httpx.Response: - return httpx.Response(207, content=_raw_multistatus(_STATUS_WITHOUT_PROP)) + entries = _parse_multistatus(_raw_multistatus(_STATUS_WITHOUT_PROP)) - src = WebDAVSource( - source_id="nc", - base_url="https://nc.example.com/dav/", - transport=_transport(handler), - ) - assert await src.head("https://nc.example.com/dav/a.md") is None + assert len(entries) == 1 + assert entries[0].revision is None + assert _parse_multistatus(_raw_multistatus(_NO_HREF)) == [] @pytest.mark.asyncio diff --git a/tests/sandbox/test_sandbox_toc.py b/tests/sandbox/test_sandbox_toc.py index 10ae264a..e76fbc7b 100644 --- a/tests/sandbox/test_sandbox_toc.py +++ b/tests/sandbox/test_sandbox_toc.py @@ -380,9 +380,20 @@ class TestVfsReadPaths: sandbox = Sandbox(temp_db_path, AppConfig(), AnalysisContext()) - content = await _read_vfs_text(sandbox, f"/documents/{doc_id}/content.txt") + # Build the VFS first, then change the stored content. A lazy + # CallbackFile reads through at access time and sees the new body; + # an eager MemoryFile mount would have captured the old one. + vfs = await sandbox._build_vfs() + sandbox._loop = asyncio.get_running_loop() - assert content == "the stored body" + async with HaikuRAG(temp_db_path, create=False) as client: + await client.update_document(doc_id, content="the rewritten body") + + content = await asyncio.to_thread( + vfs.path_read_text, PurePosixPath(f"/documents/{doc_id}/content.txt") + ) + + assert content == "the rewritten body" async def test_document_files_are_read_only(self, temp_db_path): async with HaikuRAG(temp_db_path, create=True) as client: diff --git a/tests/store/test_restore.py b/tests/store/test_restore.py index ab1460b9..b7e0d295 100644 --- a/tests/store/test_restore.py +++ b/tests/store/test_restore.py @@ -427,5 +427,7 @@ async def test_wait_protected_reraises_when_recovery_itself_is_cancelled(): outer = asyncio.create_task(_wait_protected(self_cancelling_recovery())) + # Bounded: without the re-raise the retry loop spins forever on an + # already-cancelled task, and the timeout turns that into a clean failure. with pytest.raises(asyncio.CancelledError): - await outer + await asyncio.wait_for(outer, timeout=5) diff --git a/tests/test_chunk.py b/tests/test_chunk.py index 288371e8..5fe774f3 100644 --- a/tests/test_chunk.py +++ b/tests/test_chunk.py @@ -457,12 +457,14 @@ async def test_ensure_fts_index_warns_on_failure(temp_db_path): @pytest.mark.vcr() -async def test_chunk_repository_get_by_id_and_list_all_pagination(temp_db_path): +async def test_chunk_repository_get_by_id_and_list_all_pagination( + qa_corpus: list[dict[str, str]], temp_db_path +): """get_by_id resolves a stored chunk; list_all honours limit and offset.""" async with HaikuRAG(db_path=temp_db_path, config=Config, create=True) as client: - doc = await client.create_document( - content="First paragraph.\n\nSecond paragraph.\n\nThird paragraph." - ) + # A corpus document is long enough to chunk more than once, which is + # what makes the offset assertion below meaningful. + doc = await client.create_document(content=qa_corpus[0]["document_extracted"]) assert doc.id is not None stored = await client.chunk_repository.get_by_document_id(doc.id) @@ -482,18 +484,23 @@ async def test_chunk_repository_get_by_id_and_list_all_pagination(temp_db_path): assert len(first) == 1 assert first[0].id == everything[0].id - # offset is applied even when it selects the whole set - assert len(await client.chunk_repository.list_all(offset=0)) == len(everything) + # Fail loudly if the fixture stops producing enough chunks to page. + assert len(everything) >= 2 - if len(everything) > 1: - second = await client.chunk_repository.list_all(limit=1, offset=1) - assert len(second) == 1 - assert second[0].id == everything[1].id + second = await client.chunk_repository.list_all(limit=1, offset=1) + assert len(second) == 1 + assert second[0].id == everything[1].id +@pytest.mark.vcr() async def test_chunk_search_returns_empty_for_blank_query(temp_db_path): - """A blank query with no precomputed vector has nothing to search for.""" + """A blank query with no precomputed vector short-circuits before searching.""" async with HaikuRAG(db_path=temp_db_path, config=Config, create=True) as client: + await client.create_document(content="Searchable body about elections.") + + # Positive control: the corpus is non-empty, so [] is a real decision + # rather than the answer to every query. + assert await client.chunk_repository.search("elections") assert await client.chunk_repository.search(" ") == [] diff --git a/tests/test_chunker.py b/tests/test_chunker.py index 97b0514c..c39f5831 100644 --- a/tests/test_chunker.py +++ b/tests/test_chunker.py @@ -862,7 +862,10 @@ class TestDoclingServeChunkerRefResolution: return [ { "raw_text": "body", - "doc_items": [{"self_ref": "#/texts/0", "label": "paragraph"}], + # A label the document does NOT carry, so the assertion + # proves the dict's own label was used rather than a + # lookup against the document. + "doc_items": [{"self_ref": "#/texts/0", "label": "caption"}], } ] @@ -872,4 +875,4 @@ class TestDoclingServeChunkerRefResolution: assert len(chunks) == 1 assert chunks[0].metadata["doc_item_refs"] == ["#/texts/0"] - assert chunks[0].metadata["labels"] == ["paragraph"] + assert chunks[0].metadata["labels"] == ["caption"] diff --git a/tests/test_client.py b/tests/test_client.py index 7a94b1fa..48de4ad5 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -1,3 +1,4 @@ +import asyncio import json import tempfile import threading @@ -2521,32 +2522,40 @@ async def test_visualize_chunk_falls_back_when_expansion_drops_refs(temp_db_path @pytest.mark.vcr() -async def test_import_documents_schedules_vacuum_when_enabled(temp_db_path): - """A batch import with auto_vacuum on queues a background vacuum.""" +@pytest.mark.parametrize("auto_vacuum", [True, False]) +async def test_import_documents_schedules_vacuum_per_config(temp_db_path, auto_vacuum): + """A batch import runs a background vacuum only when auto_vacuum is on.""" from haiku.rag.config import AppConfig config = AppConfig() - config.storage.auto_vacuum = True + config.storage.auto_vacuum = auto_vacuum async with HaikuRAG(temp_db_path, config=config, create=True) as client: docling_doc = await client.convert("Batch imported body.") chunks = await client.chunk(docling_doc) - await client.import_documents( - [ - DocumentImport( - docling_document=docling_doc, - chunks=chunks, - uri="test://batch-vacuum", - ) - ] - ) - assert client._vacuum_tasks + # Spy rather than inspecting _vacuum_tasks: the scheduling code + # discards each task on completion, so the set races to empty. The + # spy's count does not race, and draining the scheduled task keeps + # the assertion deterministic without pulling in the close-time pass. + with patch.object(client.store, "vacuum", new=AsyncMock()) as vacuum: + await client.import_documents( + [ + DocumentImport( + docling_document=docling_doc, + chunks=chunks, + uri="test://batch-vacuum", + ) + ] + ) + await asyncio.gather(*client._vacuum_tasks) + + assert vacuum.await_count == (1 if auto_vacuum else 0) @pytest.mark.vcr() async def test_reingesting_a_source_applies_an_explicit_title(temp_db_path): - """Re-adding an unchanged source with a new title updates just the title.""" + """Re-adding a changed source with a title updates both, in place.""" async with HaikuRAG(temp_db_path, create=True) as client: with tempfile.TemporaryDirectory() as temp_dir: source = Path(temp_dir) / "retitled.txt" @@ -2563,6 +2572,7 @@ async def test_reingesting_a_source_applies_an_explicit_title(temp_db_path): assert not isinstance(second, list) assert second.id == first.id assert second.title == "Explicit Title" + assert second.content == "changed content" async def test_update_document_rejects_unknown_id(temp_db_path): diff --git a/tests/test_config.py b/tests/test_config.py index c848beb4..21a07fc6 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -540,4 +540,4 @@ def test_load_default_config_falls_back_to_builtin_defaults(monkeypatch): config = _load_default_config() - assert config.environment == AppConfig().environment + assert config.model_dump() == AppConfig().model_dump() diff --git a/tests/test_context.py b/tests/test_context.py index dd5f1cc8..d99a70a9 100644 --- a/tests/test_context.py +++ b/tests/test_context.py @@ -1466,7 +1466,13 @@ class TestExpandWithItemsWindowEdges: rag.document_item_repository, doc.id, [resolvable, unmatched], 5000 ) - assert "untouched" in [r.content for r in expanded] + assert len(expanded) == 2 + by_content = {r.content for r in expanded} + # The unmatched result is passed through byte-for-byte... + assert "untouched" in by_content + # ...while the resolvable one actually grew to its neighbours. + grew = next(c for c in by_content if c != "untouched") + assert "paragraph 0" in grew and "paragraph 1" in grew def test_build_result_skips_positions_with_no_item(): diff --git a/tests/test_database_autocreate.py b/tests/test_database_autocreate.py index f7a0b63f..cb2759ab 100644 --- a/tests/test_database_autocreate.py +++ b/tests/test_database_autocreate.py @@ -45,8 +45,7 @@ async def test_operations_work_after_database_created(tmp_path): assert doc.content == "Test content" -@pytest.mark.asyncio -async def test_default_db_path_comes_from_storage_data_dir(tmp_path): +def test_default_db_path_comes_from_storage_data_dir(tmp_path): """Omitting db_path places the database under the configured data dir.""" from haiku.rag.client import HaikuRAG from haiku.rag.config import AppConfig @@ -62,7 +61,12 @@ async def test_default_db_path_comes_from_storage_data_dir(tmp_path): @pytest.mark.asyncio async def test_vacuum_is_callable_on_the_client(temp_db_path): """The public vacuum() delegates to the store.""" + from unittest.mock import AsyncMock, patch + from haiku.rag.client import HaikuRAG async with HaikuRAG(temp_db_path, create=True) as client: - await client.vacuum() + with patch.object(client.store, "vacuum", new=AsyncMock()) as store_vacuum: + await client.vacuum() + + store_vacuum.assert_awaited_once() diff --git a/tests/test_embedder_config.py b/tests/test_embedder_config.py index ce7561ff..8d21257b 100644 --- a/tests/test_embedder_config.py +++ b/tests/test_embedder_config.py @@ -160,8 +160,8 @@ def test_vector_dim_property_reports_configured_dimension(): "provider,env_var", [("voyageai", "VOYAGE_API_KEY"), ("cohere", "CO_API_KEY")], ) -def test_saas_providers_build_offline(monkeypatch, provider, env_var): - """Construction only wires the SDK; no request is made.""" +def test_saas_providers_are_wired_without_a_request(monkeypatch, provider, env_var): + """Construction wires the SDK and reports the configured dimension.""" monkeypatch.setenv(env_var, "test-key") config = AppConfig( embeddings=EmbeddingsConfig( @@ -174,6 +174,9 @@ def test_saas_providers_build_offline(monkeypatch, provider, env_var): embedder = get_embedder(config) assert embedder.vector_dim == 1024 + assert embedder.supports_images is False + # The provider and model reach the underlying pydantic-ai embedder. + assert embedder._embedder._model == f"{provider}:some-model" # ty: ignore[unresolved-attribute] def test_cohere_floats_rejects_missing_embeddings(): diff --git a/tests/test_lancedb_connection.py b/tests/test_lancedb_connection.py index c601a2c5..8e624250 100644 --- a/tests/test_lancedb_connection.py +++ b/tests/test_lancedb_connection.py @@ -344,6 +344,11 @@ class TestVectorIndexCreation: @pytest.mark.asyncio async def test_index_failure_is_warned_not_raised(self, temp_db_path): + import logging + + from haiku.rag.store import engine as engine_module + from tests.conftest import capture_logs + async with Store(temp_db_path, create=True) as store: await self._seed_chunks(store, 256) @@ -351,8 +356,10 @@ class TestVectorIndexCreation: raise RuntimeError("index build failed") with patch.object(store.chunks_table, "create_index", boom): - await store._ensure_vector_index() + with capture_logs(engine_module.logger, logging.WARNING) as records: + await store._ensure_vector_index() + assert any("index build failed" in r.getMessage() for r in records) indexes = await store.chunks_table.list_indices() assert not any("vector" in idx.columns for idx in indexes) @@ -378,10 +385,13 @@ class TestStoreMiscellany: @pytest.mark.asyncio async def test_vacuum_skips_when_already_running(self, temp_db_path): + import asyncio + async with Store(temp_db_path, create=True) as store: async with store._vacuum_lock: - # Returns immediately rather than blocking on the held lock. - await store.vacuum() + # Bounded: a regression here blocks on the held lock, and the + # timeout turns that deadlock into a clean failure. + await asyncio.wait_for(store.vacuum(), timeout=5) @pytest.mark.asyncio async def test_history_rejects_unknown_table(self, temp_db_path): diff --git a/tests/test_rebuild.py b/tests/test_rebuild.py index e8514b17..f76c5592 100644 --- a/tests/test_rebuild.py +++ b/tests/test_rebuild.py @@ -1071,18 +1071,38 @@ async def test_rebuild_blocks_tag_operations(temp_db_path, monkeypatch): assert set(await client.store.list_tags()) == {"post-rebuild"} +def _count_flushes(monkeypatch, rebuild_module) -> list[int]: + """Record the size of every batch handed to _flush_rebuild_batch.""" + real = rebuild_module._flush_rebuild_batch + sizes: list[int] = [] + + async def spy(client, documents, chunks): + sizes.append(len(documents)) + return await real(client, documents, chunks) + + monkeypatch.setattr(rebuild_module, "_flush_rebuild_batch", spy) + return sizes + + # --- unit-level rebuild helpers (no embedder involved) --- +@pytest.mark.vcr() async def test_flush_rebuild_batch_is_a_noop_without_documents(temp_db_path): from haiku.rag.client.rebuild import _flush_rebuild_batch async with HaikuRAG(temp_db_path, create=True) as client: + # A populated table makes "unchanged" distinguishable from "wiped". + existing = await client.create_document(content="keep me") before = await client.store.documents_table.count_rows() + assert before == 1 await _flush_rebuild_batch(client, [], []) assert await client.store.documents_table.count_rows() == before + after = await client.get_document_by_id(existing.id) + assert after is not None + assert after.updated_at == existing.updated_at async def test_mark_phase1_complete_is_idempotent(temp_db_path): @@ -1130,8 +1150,16 @@ async def test_hydrate_skips_documents_deleted_mid_rebuild(temp_db_path): assert [doc async for doc in _hydrate(client, [stored])] == [] -async def test_apply_descriptions_skips_pictures_without_text(): - """A picture whose generated description is empty is left untouched.""" +@pytest.mark.parametrize( + "description,expected_text", + [("", None), ("a red square", "a red square")], + ids=["empty_skipped", "populated_applied"], +) +async def test_apply_descriptions_writes_only_non_empty_text( + description, expected_text +): + """An empty generated description leaves the picture untouched; a real one + is written through to the picture meta.""" from haiku.rag.client.rebuild import _apply_descriptions_sync from haiku.rag.store.models.document import Document from tests.store.test_document_items import _docling_doc_with_picture @@ -1140,9 +1168,13 @@ async def test_apply_descriptions_skips_pictures_without_text(): ref = docling_doc.pictures[0].self_ref document = Document(content="x", uri="test://doc") - _apply_descriptions_sync(docling_doc, document, {ref: ""}) + _apply_descriptions_sync(docling_doc, document, {ref: description}) - assert docling_doc.pictures[0].meta is None + meta = docling_doc.pictures[0].meta + actual = getattr(getattr(meta, "description", None), "text", None) if meta else None + assert actual == expected_text + # The blob is re-compressed either way; page rasters must survive it. + assert document.docling_document is not None @pytest.mark.asyncio @@ -1234,6 +1266,22 @@ async def test_rebuild_embed_only_flushes_in_batches(temp_db_path, monkeypatch): assert doc.id is not None ids.append(doc.id) + # Phase 2 writes straight to the chunks table rather than going + # through _flush_rebuild_batch, so count the adds it makes. Patch at + # class level: embed-only recreates the table, discarding any patch + # applied to the instance that exists now. + import lancedb + + real_add = lancedb.AsyncTable.add + adds: list[int] = [] + + async def counting_add(self, records, *args, **kwargs): + if self.name == "chunks": + adds.append(len(records)) + return await real_add(self, records, *args, **kwargs) + + monkeypatch.setattr(lancedb.AsyncTable, "add", counting_add) + processed = [ doc_id async for doc_id in client.rebuild_database(mode=RebuildMode.EMBED_ONLY) @@ -1243,6 +1291,9 @@ async def test_rebuild_embed_only_flushes_in_batches(temp_db_path, monkeypatch): for doc_id in ids: assert await client.chunk_repository.get_by_document_id(doc_id) + # 3 docs at batch size 2: one mid-loop write plus the trailing one. + assert len(adds) == 2 + @pytest.mark.vcr() async def test_rechunk_raises_when_docling_blob_is_missing(temp_db_path): @@ -1266,6 +1317,7 @@ async def test_rebuild_full_flushes_in_batches(temp_db_path, monkeypatch): from haiku.rag.client import rebuild as rebuild_module monkeypatch.setattr(rebuild_module, "_REBUILD_BATCH_SIZE", 2) + flushes = _count_flushes(monkeypatch, rebuild_module) async with HaikuRAG(temp_db_path, create=True) as client: ids = [] @@ -1280,6 +1332,8 @@ async def test_rebuild_full_flushes_in_batches(temp_db_path, monkeypatch): assert sorted(processed) == sorted(ids) + assert len(flushes) == 2 + @pytest.mark.vcr() async def test_rebuild_full_warns_when_source_is_missing(temp_db_path): @@ -1324,7 +1378,13 @@ async def test_rebuild_full_flushes_pending_before_source_rebuild(temp_db_path): async for doc_id in client.rebuild_database(mode=RebuildMode.FULL) ] - assert content_doc.id in processed + # The content-path document keeps its id and must survive the + # flush that precedes the source re-ingest; the source document + # is replaced by a freshly ingested one with a new id. + assert content_doc.id in processed + assert source_doc.id not in processed + assert len(processed) == 2 + assert await client.store.documents_table.count_rows() == 2 @pytest.mark.vcr() @@ -1341,6 +1401,7 @@ async def test_rebuild_descriptions_flushes_in_batches(temp_db_path, monkeypatch config.processing.pictures = "description" monkeypatch.setattr(rebuild_module, "_REBUILD_BATCH_SIZE", 1) + flushes = _count_flushes(monkeypatch, rebuild_module) async def fake_describe(image_bytes_by_ref, *, config): return {ref: "A red square (mocked)." for ref in image_bytes_by_ref} @@ -1366,6 +1427,9 @@ async def test_rebuild_descriptions_flushes_in_batches(temp_db_path, monkeypatch assert sorted(processed) == sorted(ids) + # 2 docs at batch size 1: one flush each, none left for the trailing pass. + assert len(flushes) == 2 + @pytest.mark.vcr() async def test_rebuild_full_skips_document_deleted_mid_rebuild(temp_db_path): @@ -1408,7 +1472,10 @@ async def test_rebuild_embed_only_recovers_picture_bytes( async with HaikuRAG(temp_db_path, create=True) as rag: # The configured ollama embedder is text-only; stand in for a # multimodal one so the picture-bytes recovery branch runs. + embedded_images: list[bytes] = [] + async def fake_embed_image(image): + embedded_images.append(image) return [0.2] * rag.embedder.vector_dim monkeypatch.setattr(rag.embedder, "supports_images", True) @@ -1449,3 +1516,11 @@ async def test_rebuild_embed_only_recovers_picture_bytes( assert created.id in processed warned = any("no recoverable bytes" in r.getMessage() for r in records) assert warned is wipe_bytes + + if wipe_bytes: + # Nothing to recover, so the caption is text-embedded instead. + assert embedded_images == [] + else: + # The stored PNG was re-attached and routed through embed_image. + assert len(embedded_images) == 1 + assert embedded_images[0].startswith(b"\x89PNG") diff --git a/tests/test_utils.py b/tests/test_utils.py index 7ecbf13c..7616c653 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -140,22 +140,46 @@ Emoji test: 🚀 ✅ 📝""" @pytest.mark.parametrize( - "kwargs", + "kwargs,expected_settings", [ - {"provider": "ollama", "name": "llama3"}, - {"provider": "ollama", "name": "gpt-oss", "enable_thinking": False}, - {"provider": "ollama", "name": "gpt-oss", "enable_thinking": True}, - {"provider": "ollama", "name": "llama3", "temperature": 0.5, "max_tokens": 100}, - {"provider": "openai", "name": "gpt-4o"}, - {"provider": "openai", "name": "o1", "enable_thinking": True}, - {"provider": "openai", "name": "o1", "enable_thinking": False}, - { - "provider": "openai", - "name": "gpt-4o", - "enable_thinking": False, - "temperature": 0.7, - "max_tokens": 500, - }, + ({"provider": "ollama", "name": "llama3"}, None), + ( + {"provider": "ollama", "name": "gpt-oss", "enable_thinking": False}, + {"openai_reasoning_effort": "low"}, + ), + ( + {"provider": "ollama", "name": "gpt-oss", "enable_thinking": True}, + {"openai_reasoning_effort": "high"}, + ), + ( + { + "provider": "ollama", + "name": "llama3", + "temperature": 0.5, + "max_tokens": 100, + }, + {"temperature": 0.5, "max_tokens": 100}, + ), + ({"provider": "openai", "name": "gpt-4o"}, None), + ( + {"provider": "openai", "name": "o1", "enable_thinking": True}, + {"openai_reasoning_effort": "high"}, + ), + ( + {"provider": "openai", "name": "o1", "enable_thinking": False}, + {"openai_reasoning_effort": "low"}, + ), + ( + { + "provider": "openai", + "name": "gpt-4o", + "enable_thinking": False, + "temperature": 0.7, + "max_tokens": 500, + }, + # gpt-4o is not a reasoning model, so only the common settings land. + {"temperature": 0.7, "max_tokens": 500}, + ), ], ids=[ "ollama", @@ -168,9 +192,17 @@ Emoji test: 🚀 ✅ 📝""" "openai_all_settings", ], ) -def test_get_model_returns_openai_chat_model(kwargs): - """Every ollama and openai configuration resolves to an OpenAIChatModel.""" - assert isinstance(get_model(ModelConfig(**kwargs)), OpenAIChatModel) +def test_get_model_openai_chat_settings(kwargs, expected_settings): + """Each ollama/openai configuration maps onto the expected model settings.""" + result = get_model(ModelConfig(**kwargs)) + + assert isinstance(result, OpenAIChatModel) + if expected_settings is None: + assert result.settings is None + return + assert result.settings is not None + for key, value in expected_settings.items(): + assert result.settings.get(key) == value def test_get_model_ollama_appends_v1_to_per_model_base_url(): @@ -296,8 +328,14 @@ def test_get_model_anthropic(): @pytest.mark.skipif(not HAS_ANTHROPIC, reason="Anthropic not installed") -@pytest.mark.parametrize("enable_thinking", [True, False]) -def test_get_model_anthropic_with_thinking(enable_thinking): +@pytest.mark.parametrize( + "enable_thinking,expected_thinking", + [ + (True, {"type": "enabled", "budget_tokens": 4096}), + (False, {"type": "disabled"}), + ], +) +def test_get_model_anthropic_with_thinking(enable_thinking, expected_thinking): """Test get_model configures thinking for Anthropic.""" from pydantic_ai.models.anthropic import AnthropicModel @@ -307,7 +345,10 @@ def test_get_model_anthropic_with_thinking(enable_thinking): enable_thinking=enable_thinking, ) result = get_model(model_config) + assert isinstance(result, AnthropicModel) + assert result.settings is not None + assert result.settings.get("anthropic_thinking") == expected_thinking @pytest.mark.skipif(not HAS_GOOGLE, reason="Google not installed") @@ -343,8 +384,10 @@ def test_get_model_groq(): @pytest.mark.skipif(not HAS_GROQ, reason="Groq not installed") -@pytest.mark.parametrize("enable_thinking", [True, False]) -def test_get_model_groq_with_thinking(enable_thinking): +@pytest.mark.parametrize( + "enable_thinking,expected_format", [(True, "parsed"), (False, "hidden")] +) +def test_get_model_groq_with_thinking(enable_thinking, expected_format): """Test get_model configures thinking format for Groq.""" from pydantic_ai.models.groq import GroqModel @@ -354,7 +397,10 @@ def test_get_model_groq_with_thinking(enable_thinking): enable_thinking=enable_thinking, ) result = get_model(model_config) + assert isinstance(result, GroqModel) + assert result.settings is not None + assert result.settings.get("groq_reasoning_format") == expected_format @pytest.mark.skipif(not HAS_BEDROCK, reason="Bedrock not installed") @@ -370,19 +416,39 @@ def test_get_model_bedrock(): @pytest.mark.skipif(not HAS_BEDROCK, reason="Bedrock not installed") -@pytest.mark.parametrize("enable_thinking", [True, False]) @pytest.mark.parametrize( - "name", + "name,enable_thinking,expected_fields", [ - "anthropic.claude-3-5-sonnet-20241022-v2:0", - "openai.o3-mini-v1:0", - "qwen.qwen3-32b-v1:0", + ( + "anthropic.claude-3-5-sonnet-20241022-v2:0", + True, + {"thinking": {"type": "enabled", "budget_tokens": 4096}}, + ), + ( + "anthropic.claude-3-5-sonnet-20241022-v2:0", + False, + {"thinking": {"type": "disabled"}}, + ), + ("openai.o3-mini-v1:0", True, {"reasoning_effort": "high"}), + ("openai.o3-mini-v1:0", False, {"reasoning_effort": "low"}), + ("qwen.qwen3-32b-v1:0", True, {"reasoning_config": "high"}), + ("qwen.qwen3-32b-v1:0", False, {"reasoning_config": "low"}), # A family with no reasoning mapping leaves the request fields untouched. - "meta.llama3-70b-instruct-v1:0", + ("meta.llama3-70b-instruct-v1:0", True, None), + ("meta.llama3-70b-instruct-v1:0", False, None), + ], + ids=[ + "claude_on", + "claude_off", + "o_series_on", + "o_series_off", + "qwen_on", + "qwen_off", + "unmapped_on", + "unmapped_off", ], - ids=["claude", "o_series", "qwen", "unmapped_family"], ) -def test_get_model_bedrock_with_thinking(name, enable_thinking): +def test_get_model_bedrock_with_thinking(name, enable_thinking, expected_fields): """Each Bedrock model family maps thinking onto its own request field.""" from pydantic_ai.models.bedrock import BedrockConverseModel @@ -392,7 +458,16 @@ def test_get_model_bedrock_with_thinking(name, enable_thinking): enable_thinking=enable_thinking, ) result = get_model(model_config) + assert isinstance(result, BedrockConverseModel) + if expected_fields is None: + assert result.settings is None + return + assert result.settings is not None + assert ( + result.settings.get("bedrock_additional_model_requests_fields") + == expected_fields + ) def test_get_model_unknown_provider(): @@ -803,7 +878,12 @@ async def test_render_picture_handles_stored_bytes(stored, renders): result = await _render_picture(client, "doc1", "#/pictures/0") - assert (result is not None) is renders + if renders: + from textual_image.renderable import Image as RichImage + + assert isinstance(result, RichImage) + else: + assert result is None async def test_render_picture_without_client_returns_none(): From a602e0fbf571b38e9d22af3b296ef8a32c611973 Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Mon, 27 Jul 2026 12:11:01 +0300 Subject: [PATCH 11/16] Test vacuum against real table state --- tests/test_database_autocreate.py | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/tests/test_database_autocreate.py b/tests/test_database_autocreate.py index cb2759ab..1d14c936 100644 --- a/tests/test_database_autocreate.py +++ b/tests/test_database_autocreate.py @@ -59,14 +59,20 @@ def test_default_db_path_comes_from_storage_data_dir(tmp_path): @pytest.mark.asyncio -async def test_vacuum_is_callable_on_the_client(temp_db_path): - """The public vacuum() delegates to the store.""" - from unittest.mock import AsyncMock, patch - - from haiku.rag.client import HaikuRAG +async def test_vacuum_optimizes_tables_without_losing_rows(temp_db_path): + """The public vacuum() runs the store's optimize pass over real rows.""" + from haiku.rag.store.models.document import Document + from haiku.rag.store.repositories.document import DocumentRepository async with HaikuRAG(temp_db_path, create=True) as client: - with patch.object(client.store, "vacuum", new=AsyncMock()) as store_vacuum: - await client.vacuum() + repo = DocumentRepository(client.store) + for i in range(3): + await repo.create(Document(content=f"body {i}", uri=f"test://doc{i}")) + before = len(await client.store.documents_table.list_versions()) - store_vacuum.assert_awaited_once() + await client.vacuum() + + # Optimize compacts the per-document fragments into new versions; an + # unchanged count would mean nothing reached the tables. + assert len(await client.store.documents_table.list_versions()) > before + assert await client.count_documents() == 3 From 5200b71e2b94b25cf60181ec20ee18610fa23170 Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Mon, 27 Jul 2026 12:17:39 +0300 Subject: [PATCH 12/16] Correct two justifications Drop the coverage-gate CHANGELOG entry: it is dev infrastructure, invisible to anyone upgrading. Broaden the check_source_accessible entry to the cases it now covers. The nameless-attachment guard reads an empty /F out of untrusted PDF bytes, so it is boundary validation, not a formality; only the reason it goes uncovered belongs in the pragma. --- CHANGELOG.md | 6 +----- haiku_rag_slim/haiku/rag/client/documents.py | 5 ++++- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 64452693..8a98db2e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,14 +1,10 @@ # Changelog ## [Unreleased] -### Changed - -- Test coverage is enforced at 100% via `fail_under` in `[tool.coverage.report]`. - ### Fixed - `Store.set_haiku_version` stamps the store's own config into a recreated settings row instead of the process-global `Config`. -- `check_source_accessible` returns `False` for a URI that fails to parse instead of raising `ValueError`. +- `check_source_accessible` returns `False` for a URI it cannot resolve (unparseable host, unreadable path) instead of raising and aborting a full rebuild. ### Removed diff --git a/haiku_rag_slim/haiku/rag/client/documents.py b/haiku_rag_slim/haiku/rag/client/documents.py index a9698ce5..8cb916e4 100644 --- a/haiku_rag_slim/haiku/rag/client/documents.py +++ b/haiku_rag_slim/haiku/rag/client/documents.py @@ -570,7 +570,10 @@ def _extract_pdf_attachments( for i in range(attachment_count): att = pdf.get_attachment(i) name = att.get_name() - if not name: # pragma: no cover - pypdfium2 always names them + # A malformed PDF can carry an attachment with an empty /F, so + # this is real validation on untrusted input — it just needs a + # hand-crafted file to reach, which no fixture here produces. + if not name: # pragma: no cover - needs a malformed PDF continue data = bytes(att.get_data()) child_uri = f"{parent_uri}#attachment={quote(name, safe='')}" From ab881885294a1f2d2443c2234d8b57f477d9ad8b Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Mon, 27 Jul 2026 13:17:05 +0300 Subject: [PATCH 13/16] Keep the lazy-read test off the embedder Rewriting the document through client.update_document re-chunks and re-embeds, so the test needed an embedding endpoint that CI does not have. Write the row through the repository instead, matching how the rest of the file avoids the embedder. --- tests/sandbox/test_sandbox_toc.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/sandbox/test_sandbox_toc.py b/tests/sandbox/test_sandbox_toc.py index e76fbc7b..25ae2a04 100644 --- a/tests/sandbox/test_sandbox_toc.py +++ b/tests/sandbox/test_sandbox_toc.py @@ -386,8 +386,12 @@ class TestVfsReadPaths: vfs = await sandbox._build_vfs() sandbox._loop = asyncio.get_running_loop() + # Rewrite via the repository rather than client.update_document: the + # latter re-chunks and re-embeds, which this file deliberately avoids + # so these tests need no embedding endpoint. async with HaikuRAG(temp_db_path, create=False) as client: - await client.update_document(doc_id, content="the rewritten body") + doc.content = "the rewritten body" + await client.document_repository.update(doc) content = await asyncio.to_thread( vfs.path_read_text, PurePosixPath(f"/documents/{doc_id}/content.txt") From e186720a5eddf50af139ff74c13722ce6796dbce Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Mon, 27 Jul 2026 13:26:02 +0300 Subject: [PATCH 14/16] Report missing lines in the CI coverage output A coverage-gate failure currently shows only the percentage, which is not enough to identify the uncovered line from the log. --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index f2303707..08a32aba 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -77,7 +77,7 @@ jobs: env: HF_HUB_OFFLINE: ${{ steps.hf-cache.outputs.cache-hit == 'true' && '1' || '0' }} TRANSFORMERS_OFFLINE: ${{ steps.hf-cache.outputs.cache-hit == 'true' && '1' || '0' }} - run: uv run pytest -m "not integration" --cov=haiku --cov-report=xml + run: uv run pytest -m "not integration" --cov=haiku --cov-report=xml --cov-report=term-missing:skip-covered - name: Upload coverage to Codecov uses: codecov/codecov-action@v5 with: From 04ad3823b93d651f8ec4f13b1ea84c05f5a2329a Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Mon, 27 Jul 2026 13:35:50 +0300 Subject: [PATCH 15/16] Cover the lazy config init and restore the uv cache in CI get_config() builds its instance on first use, so the branch was covered only when a worker happened to call it before set_config(). Under xdist that depends on how cases shard across workers, which varies with the core count: covered locally, uncovered on the two-core runner. Assert it directly. setup-uv v4 bundles a cache client the GitHub cache service now rejects with 400, so the uv cache never restored and every wheel was redownloaded. Bump to v9 across all four workflows (build-docs was already drifting at v5). setup-python read requires-python (">=3.12") and installed 3.14, which uv then ignored in favour of .python-version (3.13) and downloaded itself. Point it at .python-version so the interpreter it installs is the one used. --- .github/workflows/build-docs.yml | 2 +- .github/workflows/build-publish-slim.yml | 2 +- .github/workflows/build-publish.yml | 2 +- .github/workflows/test.yml | 8 ++++---- tests/test_config.py | 16 ++++++++++++++++ 5 files changed, 23 insertions(+), 7 deletions(-) diff --git a/.github/workflows/build-docs.yml b/.github/workflows/build-docs.yml index df1f835f..c11e4966 100644 --- a/.github/workflows/build-docs.yml +++ b/.github/workflows/build-docs.yml @@ -15,7 +15,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v5 + - uses: astral-sh/setup-uv@v9 - run: uv sync --group dev - run: uv run zensical build - uses: actions/configure-pages@v5 diff --git a/.github/workflows/build-publish-slim.yml b/.github/workflows/build-publish-slim.yml index 98c3364f..864805b0 100644 --- a/.github/workflows/build-publish-slim.yml +++ b/.github/workflows/build-publish-slim.yml @@ -9,7 +9,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v4 + - uses: astral-sh/setup-uv@v9 with: enable-cache: true - name: Set up Python diff --git a/.github/workflows/build-publish.yml b/.github/workflows/build-publish.yml index 6855c1a7..ae458c27 100644 --- a/.github/workflows/build-publish.yml +++ b/.github/workflows/build-publish.yml @@ -12,7 +12,7 @@ jobs: if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }} steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v4 + - uses: astral-sh/setup-uv@v9 with: enable-cache: true - name: Set up Python diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 08a32aba..a67d820f 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -11,13 +11,13 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v4 + - uses: astral-sh/setup-uv@v9 with: enable-cache: true - name: Set up Python uses: actions/setup-python@v5 with: - python-version-file: "pyproject.toml" + python-version-file: ".python-version" - name: Install dependencies run: uv sync --all-extras - name: Lint @@ -52,13 +52,13 @@ jobs: HF_TOKEN: ${{ secrets.HF_TOKEN }} steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v4 + - uses: astral-sh/setup-uv@v9 with: enable-cache: true - name: Set up Python uses: actions/setup-python@v5 with: - python-version-file: "pyproject.toml" + python-version-file: ".python-version" - name: Install dependencies run: uv sync --all-extras - name: Cache HuggingFace models diff --git a/tests/test_config.py b/tests/test_config.py index 21a07fc6..3bcdef6d 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -541,3 +541,19 @@ def test_load_default_config_falls_back_to_builtin_defaults(monkeypatch): config = _load_default_config() assert config.model_dump() == AppConfig().model_dump() + + +def test_get_config_initialises_lazily_then_reuses(monkeypatch): + """get_config() builds the instance on first use and caches it. + + Asserted explicitly rather than relying on some test happening to be the + first caller in its worker process: under xdist that depends on how cases + shard across workers, which varies with the core count. + """ + from haiku.rag import config as config_module + + monkeypatch.setattr(config_module, "_config", None) + + first = config_module.get_config() + assert isinstance(first, AppConfig) + assert config_module.get_config() is first From eb09dc6d2c1e133d9d8994f01906fd62834669c4 Mon Sep 17 00:00:00 2001 From: Yiorgis Gozadinos Date: Mon, 27 Jul 2026 13:38:02 +0300 Subject: [PATCH 16/16] Pin setup-uv to v9.0.0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit There is no floating v9 tag — setup-uv publishes moving majors only up to v7, so v9 failed to resolve and the lint job never started. --- .github/workflows/build-docs.yml | 2 +- .github/workflows/build-publish-slim.yml | 2 +- .github/workflows/build-publish.yml | 2 +- .github/workflows/test.yml | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/build-docs.yml b/.github/workflows/build-docs.yml index c11e4966..06275e26 100644 --- a/.github/workflows/build-docs.yml +++ b/.github/workflows/build-docs.yml @@ -15,7 +15,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v9 + - uses: astral-sh/setup-uv@v9.0.0 - run: uv sync --group dev - run: uv run zensical build - uses: actions/configure-pages@v5 diff --git a/.github/workflows/build-publish-slim.yml b/.github/workflows/build-publish-slim.yml index 864805b0..e5f19e3c 100644 --- a/.github/workflows/build-publish-slim.yml +++ b/.github/workflows/build-publish-slim.yml @@ -9,7 +9,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v9 + - uses: astral-sh/setup-uv@v9.0.0 with: enable-cache: true - name: Set up Python diff --git a/.github/workflows/build-publish.yml b/.github/workflows/build-publish.yml index ae458c27..f329ae2f 100644 --- a/.github/workflows/build-publish.yml +++ b/.github/workflows/build-publish.yml @@ -12,7 +12,7 @@ jobs: if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }} steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v9 + - uses: astral-sh/setup-uv@v9.0.0 with: enable-cache: true - name: Set up Python diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index a67d820f..18ecd291 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -11,7 +11,7 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v9 + - uses: astral-sh/setup-uv@v9.0.0 with: enable-cache: true - name: Set up Python @@ -52,7 +52,7 @@ jobs: HF_TOKEN: ${{ secrets.HF_TOKEN }} steps: - uses: actions/checkout@v4 - - uses: astral-sh/setup-uv@v9 + - uses: astral-sh/setup-uv@v9.0.0 with: enable-cache: true - name: Set up Python