Compare commits

...
1 Commits
Author SHA1 Message Date
codex 1d43f2e99d Add bilingual local RAG pilot and Codex search plan
CI / tests-and-images (pull_request) Successful in 26m52s
Runner smoke test / runner-smoke (pull_request) Successful in 6s
2026-11-22 19:51:02 +00:00
5 changed files with 429 additions and 0 deletions

No files matched your search

+39
View File
@@ -0,0 +1,39 @@
# Поиск Акылдаша через Codex CLI и локальный RAG
В лаборатории `/review` пользователь задаёт вопрос на русском или кыргызском. Бэкенд передаёт исходный вопрос в Codex CLI. Codex сам формулирует поисковые запросы, получает статьи из локального индекса и возвращает их идентификаторы. Лаборатория показывает источники и варианты уточнения ситуации. Codex CLI использует подписку ChatGPT. Эмбеддинги рассчитываются локально.
## 1. Пересобрать корпус для RAG
- Использовать нормализованные выгрузки ЦБД Минюста КР. В пилот включить двуязычные акты разных типов, в том числе действующие и утратившие силу. Зафиксировать версию выгрузки, коды документов и редакций. Дату принятия, дату вступления в силу и метку редакции хранить отдельно при наличии сведений в источнике.
- Группировать фрагменты по статьям и пунктам, сохраняя идентификаторы источника и границы статьи. Для длинных статей использовать окна с перекрытием. Поиск сочетает полнотекстовый и векторный отбор, а также фильтры по языку, статусу и редакции.
- Собрать пилотный индекс отдельно. Проверить хеши и покрытие RU/KY, размер текста и векторов, выдачу по номерам актов и разговорным вопросам. Локальный SQLite с FTS5 и точным векторным поиском подходит для выборки. Перед сборкой полного корпуса проверить движок с индексированным векторным поиском, включая замер на OpenSearch с фактическими настройками хранения.
- Оценить диск для индекса, модели и runtime, временных файлов и одновременного размещения двух версий индекса. В staging проверить возобновление сборки, обновление изменившихся актов и переключение на предыдущую версию.
Первый замер и команды повторной сборки описаны в [отчёте пилота](../../tools/rag-pilot/README.md).
## 2. Установить Codex CLI
- Проверить уже установленный CLI в WSL и использовать его для локального прогона. Для staging подготовить отдельного непривилегированного воркера с фиксированной версией CLI.
- Авторизовать через `codex login --device-auth`, проверить `codex login status` и запуск `codex exec` после перезапуска. Описать обновление и повторную авторизацию воркера. [Авторизация Codex](https://learn.chatgpt.com/docs/auth?surface=cli)
## 3. Настроить Codex CLI
- Версионировать постоянные инструкции и скилл правового поиска. Явно активировать скилл на каждом запуске. Скилл задаёт поиск по юридическим терминам, проверку редакций и выбор до трёх уточнений, которые могут изменить релевантные нормы.
- Подключить локальный MCP с операциями чтения для поиска и получения статьи в конкретной редакции. Ограничить параметры, объём результата и число поисковых вызовов на вопрос. Изолировать воркер от БД пользователей, секретов и административного доступа VPS.
- Зафиксировать схему ответа с идентификаторами фрагментов, вариантами уточнения и статусом поиска. Проверить неполные данные и конфликт редакций. [Скиллы](https://learn.chatgpt.com/docs/build-skills) · [Неинтерактивный режим](https://learn.chatgpt.com/docs/non-interactive-mode)
## 4. Интегрировать CLI с бэкендом
- Добавить закрытый режим `/review`. Передавать исходный вопрос, язык, фильтры и выбранную деталь в воркер. Ограничить время и параллельность запусков. Различать отсутствие подходящей нормы, таймаут, потерю авторизации и исчерпание лимита подписки.
- Проверять принадлежность возвращённых идентификаторов результатам текущего запуска. Формировать цитаты, редакции и ссылки из корпуса. Версии индекса, скилла и CLI сохранять в снимке выдачи. В метриках хранить длительность этапов и тип сбоя. Объём сохраняемого пользовательского текста согласовать перед широким запуском.
## 5. Обновить лабораторию `/review`
- Добавить сравнение обычного поиска и Codex + RAG по одному вопросу. Показать статьи с редакцией, статусом и ссылкой на полный текст. Сохранить оценки, снимки и экспорт отзывов.
- После выдачи показать динамические кнопки уточнения и поле «Уточнить ситуацию». При повторном запуске передавать исходный вопрос и выбранную деталь. Показывать применённое уточнение с возможностью убрать его.
- Для рецензента показывать фактические запросы к корпусу, кандидатов и длительность этапов.
## 6. Проверить эффект и подготовить развёртывание
- Сравнить текущий поиск, прямой поиск по новому индексу и Codex с тем же новым индексом. Использовать размеченные вопросы RU/KY и точные запросы по реквизитам. Измерить попадание нужной статьи в топ‑3 и топ‑10, ошибки ссылок и редакций, пользу уточнения, задержку, сбои и расход лимита подписки.
- Уровень риска реализации `HIGH`. Выполнить целевые проверки данных и изоляции, обычный CI и независимое ревью. Сначала staging, затем отдельное решение о публичном запуске. Production-изменения требуют разрешения владельца, проверенного внешнего backup и восстановления, подтверждения ёмкости и готового отката.
+47
View File
@@ -0,0 +1,47 @@
# Пилот RAG для Акылдаша
Инструмент `rag_pilot.py` создаёт отдельный SQLite-файл для небольшой двуязычной выборки нормализованных документов Минюста КР. Он объединяет FTS5 и точный поиск по 384-мерным векторам. Эмбеддинги вычисляются через ONNX Runtime на CPU. Поиск открывает файл в режиме чтения. При сборке существующий файл с таким именем не перезаписывается.
Пилот использует последнюю объявленную редакцию каждого выбранного документа в локальном снимке. Это даёт воспроизводимую выборку для проверки поиска. Для проверки юридической актуальности нужны сведения из официального источника. Например, локальный снимок Трудового кодекса `230021083` содержит редакцию `60` с меткой 23.06.2026. В прошлой диагностике проекта отдельно была зафиксирована более поздняя официальная редакция. См. [диагностику релевантности](../../docs/product/search-relevance-findings-2026-11-03.md).
## Воспроизведение
Нужны Python 3.12 или новее с SQLite FTS5 и пакеты `numpy`, `onnxruntime`, `tokenizers`. Скачайте [веса ONNX](https://huggingface.co/intfloat/multilingual-e5-small/blob/main/onnx/model_qint8_avx512_vnni.onnx) как `model.onnx` и [токенизатор](https://huggingface.co/intfloat/multilingual-e5-small/blob/main/onnx/tokenizer.json) как `tokenizer.json` в `tmp/rag-model`. Скрипт проверяет SHA-256 перед загрузкой. После установки зависимостей и загрузки файлов сборка и поиск работают локально.
Из корня репозитория:
```text
python -m pip install numpy onnxruntime tokenizers
python -m unittest discover -s tools/rag-pilot -p "test_*.py"
python tools/rag-pilot/rag_pilot.py --model-dir tmp/rag-model build --corpus data/minjust-normalized --index data/rag-pilot/laws-v1.sqlite3 230021083 230029465 230000918 112451 111573
python -X utf8 tools/rag-pilot/rag_pilot.py --model-dir tmp/rag-model search --index data/rag-pilot/laws-v1.sqlite3 --language ru "Могут ли меня уволить на испытательном сроке?"
python -X utf8 tools/rag-pilot/rag_pilot.py --model-dir tmp/rag-model search --index data/rag-pilot/laws-v1.sqlite3 --language ky "Сыноо мөөнөтүндө жумуштан бошотсо болобу?"
```
Создайте каталог `data/rag-pilot` перед сборкой. Выходной файл, зависимости и веса держите в локальных каталогах проекта. Формат пилотного артефакта — `0.1.0`.
## Ограничения выборки
Пять актов подобраны вручную. Их выдача подходит для проверки работоспособности и точности ссылок на фрагменты. Для оценки релевантности понадобится независимый размеченный набор. Точный векторный поиск загружает векторы выбранного языка в память, поэтому расчёт для VPS требует отдельного замера масштабируемого движка.
## Замер 22 ноября 2026 года
| Показатель | Результат |
|---|---:|
| Акты и фрагменты | 5 актов, 797 RU и 858 KY |
| SQLite с текстом, FTS5, метаданными и векторами | 10 256 384 байта, 9,78 МиБ |
| Векторы float32 в пилотном индексе | 2 542 080 байт, 1 536 байт на фрагмент |
| Веса и токенизатор | 129,2 МиБ |
| Локальные зависимости Python на Windows | 141,6 МиБ |
`PRAGMA integrity_check` вернул `ok`. Проверенный SHA-256 файла — `8da4843cdcf8cadcc815512625d9157209a16695c2e2635829df3a02355c85e5`. По разговорному вопросу об увольнении на испытательном статья 24 локальной редакции Трудового кодекса заняла второе место на русском и первое на кыргызском. По точным запросам с номером статьи она заняла первое место на обоих языках. Кыргызские заголовки вида `24-берене`, которые нормализатор иногда размечает как обычные абзацы, распознаются при построении пилота.
### Оценка места на VPS
Равномерная случайная выборка из 512 документов манифеста (seed `20261122`) дала 4 310 фрагментов RU/KY по правилу последней редакции локального снимка. Проекция на 209 958 документов даёт 1,77 млн фрагментов. 95-процентный бутстрэп-интервал по документам составляет приблизительно 1,22–2,43 млн. Он описывает неопределённость выборки и не учитывает другой алгоритм нарезки или более свежий корпус.
```text
python tools/rag-pilot/rag_size_sample.py data/minjust-normalized tmp/rag-model/tokenizer.json
```
При плотности хранения пилота это **7–14 ГиБ на один индекс** и около 10,2 ГиБ по центральной оценке. Из них 1,75–3,48 ГиБ занимают сами векторы float32. Для планирования staging стоит заложить **25–40 ГиБ свободного места** на две версии индекса, модель, runtime и временные файлы. Read-only замер `df` на VPS показал **44,1 ГиБ свободно на `/`**. В расчёт не входят исходная выгрузка, исторические редакции, внешние резервные копии и накладные расходы выбранного движка. Размер и пиковое потребление памяти OpenSearch предстоит измерить до развёртывания.
+225
View File
@@ -0,0 +1,225 @@
"""Build and query an isolated bilingual retrieval pilot on CPU."""
import argparse
from collections import defaultdict
from contextlib import closing
import hashlib
from itertools import batched
import json
import os
from pathlib import Path
import re
import sqlite3
import tempfile
import numpy as np
import onnxruntime as ort
from tokenizers import Tokenizer
MODEL = "intfloat/multilingual-e5-small"
MODEL_FILES = {
"model.onnx": "dd476dd0c2514e9b9be83aeb3853fac0763e0bdf4a71645407587d77c48a2d88",
"tokenizer.json": "0b44a9d7b51c3c62626640cda0e2c2f70fdacdc25bbbd68038369d14ebdf4c39",
}
LANGUAGES = ("ru", "ky")
DIMENSIONS = 384
FORMAT_VERSION = "0.1.0"
WINDOW_SIZE = 360
WINDOW_STEP = 328
KY_ARTICLE = re.compile(r"^\s*\d+(?:[-‑–]\d+)*\s*[-‑–]\s*берене\b", re.IGNORECASE)
class Embedder:
def __init__(self, model_dir):
for name, expected in MODEL_FILES.items():
with (model_dir / name).open("rb") as source:
if hashlib.file_digest(source, "sha256").hexdigest() != expected:
raise ValueError(f"Unexpected model file checksum: {name}")
self.tokenizer = Tokenizer.from_file(str(model_dir / "tokenizer.json"))
self.encoder = Tokenizer.from_file(str(model_dir / "tokenizer.json"))
self.encoder.enable_truncation(max_length=512)
self.encoder.enable_padding(pad_id=self.encoder.token_to_id("<pad>"))
options = ort.SessionOptions()
options.intra_op_num_threads = min(os.cpu_count() or 1, 6)
self.session = ort.InferenceSession(
str(model_dir / "model.onnx"), sess_options=options, providers=["CPUExecutionProvider"]
)
self.input_names = {entry.name for entry in self.session.get_inputs()}
def embed(self, texts):
encoded = self.encoder.encode_batch(texts)
mask = np.asarray([item.attention_mask for item in encoded], dtype=np.int64)
inputs = {
"input_ids": np.asarray([item.ids for item in encoded], dtype=np.int64),
"attention_mask": mask,
"token_type_ids": np.zeros_like(mask),
}
hidden = self.session.run(None, {key: inputs[key] for key in self.input_names})[0]
pooled = (hidden * mask[:, :, None]).sum(axis=1) / mask.sum(axis=1, keepdims=True)
vectors = (pooled / np.linalg.norm(pooled, axis=1, keepdims=True)).astype("<f4")
if vectors.shape != (len(texts), DIMENSIONS) or not np.isfinite(vectors).all():
raise ValueError("Invalid embedding output")
return vectors
def windows(self, text):
offsets = self.tokenizer.encode(text, add_special_tokens=False).offsets
for start, end in token_windows(len(offsets)):
yield text[offsets[start][0]:offsets[end - 1][1]].strip()
def token_windows(token_count):
for start in range(0, token_count, WINDOW_STEP):
end = min(start + WINDOW_SIZE, token_count)
yield start, end
if end == token_count:
break
def load_json(path):
return json.loads(path.read_text(encoding="utf-8"))
def is_article(fragment, language):
return fragment["type"] == "article" or (
language == "ky" and KY_ARTICLE.match(fragment["text"]) is not None
)
def sections(fragments, code, edition, language):
section = []
for position, fragment in enumerate(fragments, 1):
expected = f"document:{code}:edition:{edition}:lang:{language}:fragment:{position}"
if fragment["id"] != expected or fragment["position"] != position:
raise ValueError(f"Invalid fragment: {expected}")
if fragment["text_sha256"] != hashlib.sha256(fragment["text"].encode()).hexdigest():
raise ValueError(f"Fragment checksum mismatch: {expected}")
if section and (fragment["type"] == "heading" or is_article(fragment, language)):
yield section
section = []
section.append(fragment)
if section:
yield section
def corpus_chunks(root, codes, embedder):
for code in codes:
directory = root / "documents" / code
document = load_json(directory / "document.json")
if document["source_code"] != code:
raise ValueError(f"Wrong document code: {code}")
declared = document["editions"][-1]
edition = str(declared["source_code"])
if not edition.isascii() or not edition.isdecimal():
raise ValueError(f"Invalid edition code: {edition}")
for language in LANGUAGES:
fragments = load_json(directory / "editions" / edition / language / "fragments.json")
if not fragments:
raise ValueError(f"Missing {language} fragments: {code}/{edition}")
title = document["name"][language]
status = document["status"][language]
for section in sections(fragments, code, edition, language):
first = section[0]
article = first["text"] if is_article(first, language) else ""
text = "\n".join(fragment["text"] for fragment in section)
for part, chunk in enumerate(embedder.windows(text), 1):
yield (
f"{first['id']}:part:{part}", code, edition, language, title, status,
declared["name"].get(language), first["position"], section[-1]["position"],
first["source_path"], first["source_sha256"], article, chunk,
)
def build(root, output, codes, embedder):
if output.exists():
raise FileExistsError(output)
descriptor, name = tempfile.mkstemp(dir=output.parent, suffix=".sqlite3")
os.close(descriptor)
staging = Path(name)
try:
with closing(sqlite3.connect(staging)) as db, db:
db.executescript("""
CREATE TABLE manifest (key TEXT PRIMARY KEY, value TEXT NOT NULL);
CREATE TABLE chunks (
id TEXT UNIQUE NOT NULL, code TEXT NOT NULL, edition TEXT NOT NULL,
language TEXT NOT NULL, title TEXT NOT NULL, status TEXT NOT NULL,
edition_label TEXT, first_fragment INTEGER NOT NULL, last_fragment INTEGER NOT NULL,
source_path TEXT NOT NULL, source_sha256 TEXT NOT NULL,
article TEXT NOT NULL, text TEXT NOT NULL
);
CREATE INDEX chunks_language ON chunks(language);
CREATE TABLE vectors (id INTEGER PRIMARY KEY, value BLOB NOT NULL CHECK(length(value)=1536));
CREATE VIRTUAL TABLE lexical USING fts5(title, article, text, content='chunks', tokenize='unicode61');
""")
db.executemany("INSERT INTO manifest VALUES (?, ?)", (
("format", FORMAT_VERSION), ("model", MODEL), ("codes", ",".join(codes)),
("model_files_sha256", json.dumps(MODEL_FILES, sort_keys=True)),
("edition_policy", "last declared edition in the local snapshot"),
))
for batch in batched(corpus_chunks(root, codes, embedder), 12):
texts = [f"passage: {row[4][:160]}\n{row[-2][:100]}\n{row[-1]}" for row in batch]
vectors = embedder.embed(texts)
for row, vector in zip(batch, vectors, strict=True):
cursor = db.execute("INSERT INTO chunks VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", row)
db.execute("INSERT INTO vectors VALUES (?, ?)", (cursor.lastrowid, vector.tobytes()))
db.execute("INSERT INTO lexical(lexical) VALUES ('rebuild')")
db.execute("INSERT INTO lexical(lexical, rank) VALUES ('integrity-check', 1)")
if db.execute("PRAGMA integrity_check").fetchone() != ("ok",):
raise ValueError("Index integrity check failed")
if os.name == "nt":
os.rename(staging, output)
else:
os.link(staging, output)
finally:
staging.unlink(missing_ok=True)
def search(index, query, language, limit, embedder):
words = re.findall(r"[^\W_]+", query, flags=re.UNICODE)
if not words:
raise ValueError("Query must contain letters or digits")
with closing(sqlite3.connect(index.resolve().as_uri() + "?mode=ro", uri=True)) as db:
db.row_factory = sqlite3.Row
vector_rows = db.execute("""SELECT v.id,v.value FROM chunks c JOIN vectors v ON v.id=c.rowid
WHERE c.language=? ORDER BY v.id""", (language,)).fetchall()
if not vector_rows:
return []
matrix = np.frombuffer(b"".join(row["value"] for row in vector_rows), dtype="<f4").reshape(-1, DIMENSIONS)
similarities = matrix @ embedder.embed([f"query: {query}"])[0]
semantic = [vector_rows[i]["id"] for i in np.argsort(-similarities, kind="stable")[:30]]
expression = " OR ".join(f'"{word}"' for word in dict.fromkeys(words))
lexical = [row[0] for row in db.execute("""SELECT c.rowid FROM lexical
JOIN chunks c ON c.rowid=lexical.rowid WHERE lexical MATCH ? AND c.language=?
ORDER BY bm25(lexical), c.rowid LIMIT 30""", (expression, language))]
combined = defaultdict(float)
for ranking in (semantic, lexical):
for rank, rowid in enumerate(ranking, 1):
combined[rowid] += 1 / (60 + rank)
hits = sorted(combined, key=lambda rowid: (-combined[rowid], rowid))[:limit]
return [dict(db.execute("SELECT * FROM chunks WHERE rowid=?", (rowid,)).fetchone()) for rowid in hits]
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--model-dir", required=True, type=Path)
commands = parser.add_subparsers(dest="command", required=True)
builder = commands.add_parser("build")
builder.add_argument("--corpus", required=True, type=Path)
builder.add_argument("--index", required=True, type=Path)
builder.add_argument("codes", nargs="+")
reader = commands.add_parser("search")
reader.add_argument("--index", required=True, type=Path)
reader.add_argument("--language", choices=LANGUAGES, required=True)
reader.add_argument("--limit", type=int, default=5, choices=range(1, 31), metavar="1..30")
reader.add_argument("query")
args = parser.parse_args()
if args.command == "build":
if len(set(args.codes)) != len(args.codes) or not all(code.isascii() and code.isdecimal() for code in args.codes):
parser.error("codes must be unique decimal document IDs")
build(args.corpus, args.index, args.codes, Embedder(args.model_dir))
else:
print(json.dumps(search(args.index, args.query, args.language, args.limit, Embedder(args.model_dir)), ensure_ascii=False))
if __name__ == "__main__":
main()
+49
View File
@@ -0,0 +1,49 @@
"""Estimate latest-edition chunk count with a fixed uniform document sample."""
import json
from pathlib import Path
import random
import sqlite3
import statistics
import sys
from tokenizers import Tokenizer
from rag_pilot import LANGUAGES, load_json, sections, token_windows
def main(root, tokenizer_file):
with sqlite3.connect((root / "manifest.sqlite3").resolve().as_uri() + "?mode=ro", uri=True) as db:
codes = [row[0] for row in db.execute("SELECT code FROM documents WHERE state='success' ORDER BY code")]
tokenizer = Tokenizer.from_file(str(tokenizer_file))
rng = random.Random(20261122)
sample = rng.sample(codes, 512)
counts = []
language_counts = dict.fromkeys(LANGUAGES, 0)
for code in sample:
directory = root / "documents" / code
document = load_json(directory / "document.json")
editions = document.get("editions") or []
count = 0
if editions:
for language in language_counts:
edition = str(editions[-1]["source_code"])
path = directory / "editions" / edition / language / "fragments.json"
if not path.is_file():
continue
blocks = ["\n".join(fragment["text"] for fragment in section)
for section in sections(load_json(path), code, edition, language)]
encoded = tokenizer.encode_batch(blocks, add_special_tokens=False)
windows = sum(1 for entry in encoded for _ in token_windows(len(entry.ids)))
language_counts[language] += windows
count += windows
counts.append(count)
# Resample at document level so the language and article lengths stay linked.
estimates = sorted(statistics.mean(rng.choices(counts, k=len(counts))) * len(codes) for _ in range(2000))
print(json.dumps({"documents": len(codes), "sample": len(sample), "languages": language_counts,
"largest_sampled_document": max(counts), "projected_chunks": round(statistics.mean(counts) * len(codes)),
"bootstrap_low": round(estimates[50]), "bootstrap_high": round(estimates[1949])}))
if __name__ == "__main__":
main(*map(Path, sys.argv[1:]))
+69
View File
@@ -0,0 +1,69 @@
import hashlib
import json
from pathlib import Path
import sqlite3
import tempfile
import unittest
import numpy as np
from rag_pilot import DIMENSIONS, build, search
class FixedEmbedder:
def windows(self, text):
yield text
def embed(self, texts):
vectors = np.zeros((len(texts), DIMENSIONS), dtype="<f4")
vectors[:, 0] = 1
return vectors
class RagPilotTest(unittest.TestCase):
def setUp(self):
workspace = tempfile.TemporaryDirectory()
self.addCleanup(workspace.cleanup)
self.root = Path(workspace.name)
self.output = self.root / "pilot.sqlite3"
self.embedder = FixedEmbedder()
document = self.root / "documents" / "1"
self.edition = document / "editions" / "10"
for language, text in (("ru", "Статья 1. Испытание"), ("ky", "1-берене. Сыноо")):
folder = self.edition / language
folder.mkdir(parents=True)
item = {"id": f"document:1:edition:10:lang:{language}:fragment:1", "text": text,
"type": "article" if language == "ru" else "paragraph", "position": 1,
"text_sha256": hashlib.sha256(text.encode()).hexdigest(),
"source_path": f"documents/1/editions/10/{language}.html", "source_sha256": "0" * 64}
(folder / "fragments.json").write_text(json.dumps([item]), encoding="utf-8")
metadata = {"source_code": "1", "name": {"ru": "Тестовый акт", "ky": "Сыноо акты"},
"status": {"ru": "Действует", "ky": "Күчүндө"},
"editions": [{"source_code": "10", "name": {"ru": "Редакция 10", "ky": "10-редакция"}}]}
(document / "document.json").write_text(json.dumps(metadata), encoding="utf-8")
def test_bilingual_search_returns_source_identity_and_cannot_overwrite(self):
build(self.root, self.output, ["1"], self.embedder)
for language, query in (("ru", "Испытание"), ("ky", "Сыноо")):
hits = search(self.output, f'{query} " OR *', language, 3, self.embedder)
self.assertEqual([hit["id"] for hit in hits], [f"document:1:edition:10:lang:{language}:fragment:1:part:1"])
self.assertIn(f"{language}.html", hits[0]["source_path"])
self.assertTrue(hits[0]["article"])
before = self.output.read_bytes()
with self.assertRaises(FileExistsError):
build(self.root, self.output, ["1"], self.embedder)
self.assertEqual(before, self.output.read_bytes())
def test_corrupt_input_does_not_publish_partial_index(self):
path = self.edition / "ky" / "fragments.json"
items = json.loads(path.read_text(encoding="utf-8"))
items[0]["text"] += " corrupt"
path.write_text(json.dumps(items), encoding="utf-8")
with self.assertRaisesRegex(ValueError, "checksum"):
build(self.root, self.output, ["1"], self.embedder)
self.assertFalse(self.output.exists())
self.assertEqual(list(self.root.glob("*.sqlite3")), [])
if __name__ == "__main__":
unittest.main()