diff --git a/.gitattributes b/.gitattributes index bed0738c7eeb449bca98b5d2f33c89a1ee56349a..416f02acd37983301b8ebeb9146b3dfb0e20b2d4 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,60 +1,2 @@ -*.7z filter=lfs diff=lfs merge=lfs -text -*.arrow filter=lfs diff=lfs merge=lfs -text -*.avro filter=lfs diff=lfs merge=lfs -text -*.bin filter=lfs diff=lfs merge=lfs -text -*.bz2 filter=lfs diff=lfs merge=lfs -text -*.ckpt filter=lfs diff=lfs merge=lfs -text -*.ftz filter=lfs diff=lfs merge=lfs -text -*.gz filter=lfs diff=lfs merge=lfs -text -*.h5 filter=lfs diff=lfs merge=lfs -text -*.joblib filter=lfs diff=lfs merge=lfs -text -*.lfs.* filter=lfs diff=lfs merge=lfs -text -*.lz4 filter=lfs diff=lfs merge=lfs -text -*.mds filter=lfs diff=lfs merge=lfs -text -*.mlmodel filter=lfs diff=lfs merge=lfs -text -*.model filter=lfs diff=lfs merge=lfs -text -*.msgpack filter=lfs diff=lfs merge=lfs -text -*.npy filter=lfs diff=lfs merge=lfs -text -*.npz filter=lfs diff=lfs merge=lfs -text -*.onnx filter=lfs diff=lfs merge=lfs -text -*.ot filter=lfs diff=lfs merge=lfs -text *.parquet filter=lfs diff=lfs merge=lfs -text -*.pb filter=lfs diff=lfs merge=lfs -text -*.pickle filter=lfs diff=lfs merge=lfs -text -*.pkl filter=lfs diff=lfs merge=lfs -text -*.pt filter=lfs diff=lfs merge=lfs -text -*.pth filter=lfs diff=lfs merge=lfs -text -*.rar filter=lfs diff=lfs merge=lfs -text -*.safetensors filter=lfs diff=lfs merge=lfs -text -saved_model/**/* filter=lfs diff=lfs merge=lfs -text -*.tar.* filter=lfs diff=lfs merge=lfs -text -*.tar filter=lfs diff=lfs merge=lfs -text -*.tflite filter=lfs diff=lfs merge=lfs -text -*.tgz filter=lfs diff=lfs merge=lfs -text -*.wasm filter=lfs diff=lfs merge=lfs -text -*.xz filter=lfs diff=lfs merge=lfs -text -*.zip filter=lfs diff=lfs merge=lfs -text -*.zst filter=lfs diff=lfs merge=lfs -text -*tfevents* filter=lfs diff=lfs merge=lfs -text -# Audio files - uncompressed -*.pcm filter=lfs diff=lfs merge=lfs -text -*.sam filter=lfs diff=lfs merge=lfs -text -*.raw filter=lfs diff=lfs merge=lfs -text -# Audio files - compressed -*.aac filter=lfs diff=lfs merge=lfs -text -*.flac filter=lfs diff=lfs merge=lfs -text -*.mp3 filter=lfs diff=lfs merge=lfs -text -*.ogg filter=lfs diff=lfs merge=lfs -text -*.wav filter=lfs diff=lfs merge=lfs -text -# Image files - uncompressed -*.bmp filter=lfs diff=lfs merge=lfs -text -*.gif filter=lfs diff=lfs merge=lfs -text -*.png filter=lfs diff=lfs merge=lfs -text -*.tiff filter=lfs diff=lfs merge=lfs -text -# Image files - compressed -*.jpg filter=lfs diff=lfs merge=lfs -text -*.jpeg filter=lfs diff=lfs merge=lfs -text -*.webp filter=lfs diff=lfs merge=lfs -text -# Video files - compressed -*.mp4 filter=lfs diff=lfs merge=lfs -text -*.webm filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text diff --git a/README.md b/README.md index 4996388571c804116d5e96b52fc6ec4d2fd6fbf5..eebfe1fa79bcd0d42fbe862d08d9fe3ac01e3646 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,132 @@ -# justicedao/ipfs_hongkong_laws_ir +--- +license: other +task_categories: +- text-retrieval +tags: +- legal +- law +- graphrag +- bm25 +- research +- not-legal-advice +- hongkong +pretty_name: Hong Kong laws IR (CID-keyed GraphRAG) +configs: +- config_name: corpus + data_files: + - split: train + path: data/corpus/*.parquet +- config_name: bm25_documents + data_files: + - split: train + path: data/bm25/documents/*.parquet +- config_name: bm25_postings + data_files: + - split: train + path: data/bm25/postings/*.parquet +- config_name: bm25_keyword_index + data_files: + - split: train + path: indexes/bm25_keyword_shards.parquet +- config_name: vectors + data_files: + - split: train + path: data/vectors/*.parquet +- config_name: vector_meta_index + data_files: + - split: train + path: indexes/vector_chunks.parquet +- config_name: graph_nodes + data_files: + - split: train + path: data/graph/nodes/*.parquet +- config_name: graph_edges + data_files: + - split: train + path: data/graph/edges/*.parquet +- config_name: graph_outgoing_adjacency + data_files: + - split: train + path: data/graph/adjacency/outgoing/*.parquet +- config_name: graph_incoming_adjacency + data_files: + - split: train + path: data/graph/adjacency/incoming/*.parquet +--- -Hong Kong laws IR release. +# Hong Kong legislation IR (CID-keyed sparse GraphRAG) + +Research retrieval release of `endomorphosis/ipfs_hongkong_laws` (revision `e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc`) packaged as +`country-laws-ir-graphrag/v1` (layout family `skillcenter-huggingface-release/v3` / publicus-ir). + +**Not legal advice.** This is a research snapshot. The official gazette / +authentic source of Hong Kong prevails over this corpus. Retrieved documents +and graph edges are retrieval evidence only. No legal text was invented. + +Primary key: `entry_cid` (CIDv1 raw sha2-256 of a canonical identity record). +Integer `document_index` values are compact shard pointers, not identities. + +Target Hub id (packaging metadata only): `justicedao/ipfs_hongkong_laws_ir`. + +## Counts + +| Field | Value | +| --- | --- | +| Laws (corpus units) | 0 | +| Articles (corpus units) | 85615 | +| Canonical docs | 85615 | +| BM25 terms | 46254 | +| BM25 postings | 3595440 | +| Graph nodes | 89587 | +| Graph edges | 599305 | +| Vectors | 85615 × 384-d `thenlper/gte-small` (embedded) | + +## Canonical fields + +`entry_cid`, `law_cid`, `record_type`, `jurisdiction`, `language`, +`instrument_id`, `instrument_title`, `article_number`, `article_title`, +`title`, `body`, `source_url`, `snapshot_date`, `coverage`, `license`, +`collector`, `source_dataset`, `source_revision`. + +Unit policy: prefer article/section rows; fall back to law-level when +`articles.parquet` is empty. + +## Index layout + +Zstandard parquet shards with at most 4,096 rows. + +- `indexes/bm25_keyword_shards.parquet` — lexical term ranges → BM25 posting shards +- `indexes/vector_chunks.parquet` — semantic routing centroids (rows sorted by cosine to shard centroid) +- `indexes/corpus_chunks.parquet` — document ranges → corpus shards +- `data/graph/nodes` / `data/graph/edges` — property graph +- `data/graph/adjacency/{incoming,outgoing}` — score-ordered neighbor pages + +BM25: Okapi k1=1.2, b=0.75, title_weight=5, body_weight=1 (FTS5 unicode61-style tokenizer). + +Graph: one node per `entry_cid` plus facet nodes (`_facet_cid(kind, value)` for +jurisdiction, language, instrument, source, status). Neighbor edges +`BM25_NEIGHBOR_OF` (k=8) carry score and matched terms. Structural edges: +`ARTICLE_OF` (article → parent law) when articles exist, plus `IDENTIFIED_BY_ELI` +/ `IDENTIFIED_BY` only when those identifiers are present in the source. + +## Query + +``` +python scripts/query_country_laws_hf.py --local-dir . bm25 "constitution" --top-k 10 +python scripts/query_country_laws_hf.py --local-dir . vector "money laundering" --top-k 10 +python scripts/query_country_laws_hf.py --local-dir . graph neighbors +``` + +## Publish later (operator) + +``` +export HF_TOKEN=... # never commit +hf upload-large-folder justicedao/ipfs_hongkong_laws_ir . \ + --repo-type dataset --no-private --num-workers 8 \ + --exclude "**/__pycache__/**" --exclude "**/*.pyc" +``` + +## Provenance + +Packaged by country-laws-ir. Upstream collector and official license remain those +of `endomorphosis/ipfs_hongkong_laws`. CIDs identify local content; they do not prove public IPFS pinning. diff --git a/build.py b/build.py new file mode 100644 index 0000000000000000000000000000000000000000..768973af97da5ea96deef2b5b7bbbc06909d9ebe --- /dev/null +++ b/build.py @@ -0,0 +1,501 @@ +"""End-to-end build: normalize → incremental vectors → BM25 → graph → package. + +Default mode is ``auto``: skip when the endomorphosis source revision is +unchanged, otherwise delta-refresh embeddings by ``entry_cid`` and rebuild +BM25/graph from the current corpus. Publication to ``justicedao/*`` is opt-in +via ``upload=True``. +""" + +from __future__ import annotations + +import os + +import json + +import pandas as pd +import traceback +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from .sparse import export_sparse_graphrag +from .mem import MemAbort, checkpoint, log_mem +from .spill import spill_dir_for, spill_pickle +from .package import package_from_spill, package_release +from .catalog import get_country, indexable_countries, target_repo + +from .incremental import ( + fetch_hub_prior, + load_embedding_cache, + load_prior_release, + load_release_vectors_by_cid, + merge_embedding_maps, + plan_rebuild, + save_embedding_cache, +) +from .normalize import build_corpus, load_source +from .auth import configure_hf +from .vectors import ( + DIMENSION, + MODEL_NAME, + assemble_embeddings, + embeddings_by_cid, + layout_stub_vectors, + layout_vectors, + select_device, +) + +ROOT = Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(Path.home() / ".ipfs_datasets" / "country-laws-ir"))) +CACHE = ROOT / "cache" +RELEASES = ROOT / "releases" +REPORTS = ROOT / "reports" +PROGRESS = ROOT / "progress.jsonl" + + +def _log(msg: str) -> None: + ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + print(f"[{ts}] {msg}", flush=True) + + +def record_progress(event: dict[str, Any]) -> None: + event = dict(event) + event.setdefault("ts", datetime.now(timezone.utc).isoformat()) + PROGRESS.parent.mkdir(parents=True, exist_ok=True) + lock_path = PROGRESS.with_suffix(".lock") + with lock_path.open("a", encoding="utf-8") as lock_fh: + try: + import fcntl + + fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX) + except Exception: + pass + with PROGRESS.open("a", encoding="utf-8") as f: + f.write(json.dumps(event, ensure_ascii=False) + "\n") + + +def _prior_dir_for( + slug: str, + out: Path, + prior_dir: Path | None, + *, + fetch_hub: bool = True, +) -> Path | None: + if prior_dir is not None: + return Path(prior_dir) + if out.is_dir() and (out / "manifest.json").is_file(): + return out + default = RELEASES / f"ipfs_{slug}_laws_ir" + if default.is_dir() and (default / "manifest.json").is_file() and default.resolve() != out.resolve(): + return default + if not fetch_hub: + return None + hub = fetch_hub_prior(slug, cache_root=CACHE / "hub-ir") + if hub is not None: + _log(f"using justicedao prior {hub}") + return hub + + +def _encode_vectors( + *, + corpus: pd.DataFrame, + country_slug: str, + prior, + plan, + skip_vectors: bool, + device: str, +) -> tuple[dict[str, Any], str | None, dict[str, Any]]: + import gc + + vector_report: dict[str, Any] = {"status": "stub"} + vector_blocker = None + if skip_vectors: + vectors = layout_stub_vectors(corpus, reason="skip_vectors flag") + return vectors, "skip_vectors", {"status": "stub", "reason": "skip_vectors"} + + cid_cache_path = CACHE / "embeddings" / f"{country_slug}_by_cid.parquet" + prior_by_cid = {} + if plan.reuse_embeddings: + prior_by_cid = merge_embedding_maps( + load_embedding_cache(cid_cache_path), + None if prior is None else load_release_vectors_by_cid(prior.directory), + ) + _log(f"embedding cache reused_cids={len(prior_by_cid)}") + try: + positional = CACHE / "embeddings" / f"{country_slug}.npy" + resolved, fallback = select_device(device) + if fallback: + _log(f"embedding device fallback requested={device} using={resolved}") + embeddings, vector_report = assemble_embeddings( + corpus, + prior_by_cid, + encode_missing=True, + device=resolved, + checkpoint_path=str(positional), + ) + if ( + vector_report.get("status") in {"stub_missing_encoder", "incomplete"} + and not int(vector_report.get("n_reused") or 0) + ): + vector_blocker = vector_report.get("reason") or vector_report.get("status") + vectors = layout_stub_vectors(corpus, reason=str(vector_blocker)) + return vectors, vector_blocker, vector_report + vectors = layout_vectors(corpus, embeddings) + if int(vector_report.get("n_reused") or 0) and vector_report.get("status") != "reused": + vectors["stats"]["status"] = "partial" + vectors["stats"]["n_reused"] = int(vector_report.get("n_reused") or 0) + vectors["stats"]["n_missing"] = int(vector_report.get("n_missing") or 0) + vector_blocker = vector_report.get("reason") or vector_report.get("status") + save_embedding_cache( + cid_cache_path, + merge_embedding_maps(prior_by_cid, embeddings_by_cid(corpus, embeddings)), + model_name=MODEL_NAME, + dimension=DIMENSION, + ) + del embeddings + gc.collect() + _log( + f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']} " + f"reused={vector_report.get('n_reused')} encoded={vector_report.get('n_encoded')}" + ) + return vectors, None, vector_report + except Exception as exc: + vector_blocker = f"embedding_failed: {exc}" + _log(f"vector embedding failed; writing stub ({exc})") + vectors = layout_stub_vectors(corpus, reason=vector_blocker) + return vectors, vector_blocker, {"status": "failed", "reason": str(exc)} + + +def build_country( + source: str, + out: Path | None = None, + upload: bool = False, + device: str = "cuda", + neighbor_k: int = 8, + skip_vectors: bool = False, + mode: str = "auto", + force: bool = False, + prior_dir: Path | None = None, + fetch_hub_prior_ir: bool = True, +) -> dict[str, Any]: + country = get_country(source) + if not country.get("indexable", True): + raise RuntimeError(f"{country['repo']} is excluded: {country.get('skip_reason')}") + repo = country["repo"] + out = Path(out) if out else RELEASES / f"ipfs_{country['slug']}_laws_ir" + local_dir = country.get("local_source_dir") or ( + str(Path(source).resolve()) + if Path(source).is_dir() + and ( + (Path(source) / "data" / "laws.parquet").is_file() + or (Path(source) / "laws.parquet").is_file() + ) + else None + ) + _log( + f"build start {repo} -> {out} (upload={upload} mode={mode} force={force}) local={local_dir}" + ) + configure_hf() + CACHE.mkdir(parents=True, exist_ok=True) + REPORTS.mkdir(parents=True, exist_ok=True) + laws, articles, source_meta = load_source(local_dir or repo, CACHE) + _log( + f"source loaded laws={source_meta['n_laws_source']} " + f"articles={source_meta['n_articles_source']} rev={source_meta['source_revision']}" + ) + prior = load_prior_release( + _prior_dir_for( + country["slug"], + out, + prior_dir, + fetch_hub=fetch_hub_prior_ir, + ) + ) + plan = plan_rebuild( + mode=mode, + source_meta=source_meta, + prior=prior, + force=force, + rebuild_stub_vectors=not skip_vectors, + ) + if plan.skip_build: + _log(f"skip unchanged {country['slug']} rev={plan.source_revision}") + result = { + "country": country["slug"], + "source": repo, + "source_revision": source_meta["source_revision"], + "out": str(out), + "target_hub_id": target_repo(country["slug"]), + "skipped": True, + "incremental": plan.to_dict(), + "normalization": {"n_out": plan.delta.current_count if plan.delta else 0}, + "vector_blocker": None, + "neighbor_via": None, + "schema_version": "country-laws-ir-graphrag/v1", + } + record_progress({"event": "skipped_unchanged", **{k: v for k, v in result.items() if k != "normalization"}}) + return result + + corpus, norm_report = build_corpus(laws, articles, source_meta) + report_path = REPORTS / f"{country['slug']}_normalization.json" + report_path.write_text(json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + (REPORTS / "normalization.json").write_text( + json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8" + ) + _log( + f"normalized docs={len(corpus)} unit={norm_report['unit']} " + f"dropped={norm_report['n_dropped_total']} report={report_path}" + ) + if corpus.empty: + raise RuntimeError("Normalized corpus is empty; refusing to package") + verdict = (norm_report or {}).get("verification") or {} + if verdict.get("blocks_graphrag") and not force: + from .verify import NormalizationAdmissionError + + raise NormalizationAdmissionError( + f"{country['slug']} failed normalization verifiers: {verdict.get('failed_ids')}" + ) + + import gc + + plan = plan_rebuild( + mode=mode, + source_meta=source_meta, + prior=prior, + current_corpus=corpus, + force=force, + rebuild_stub_vectors=not skip_vectors, + ) + _log( + f"rebuild kind={plan.kind.value} reuse_embeddings={plan.reuse_embeddings} " + f"added={0 if plan.delta is None else plan.delta.n_added} " + f"removed={0 if plan.delta is None else plan.delta.n_removed}" + ) + + n_docs = len(corpus) + spill = spill_dir_for(country["slug"], CACHE) + spill.mkdir(parents=True, exist_ok=True) + corpus_ckpt = CACHE / f"{country['slug']}_corpus.parquet" + corpus.to_parquet(corpus_ckpt, index=False) + checkpoint("after_normalize", log=_log) + + vectors, vector_blocker, vector_report = _encode_vectors( + corpus=corpus, + country_slug=country["slug"], + prior=prior, + plan=plan, + skip_vectors=skip_vectors, + device=device, + ) + spill_pickle(spill / "vectors.pkl", vectors) + del vectors + gc.collect() + checkpoint("vectors_spilled", log=_log) + extra_manifest = {"incremental": {**plan.to_dict(), "vectors": vector_report}} + + neighbor_via = "hf_graphrag" + if out.exists(): + import shutil as _shutil + + _shutil.rmtree(out) + out.mkdir(parents=True, exist_ok=True) + _log(f"sparse GraphRAG via hf_graphrag.bm25/graph parquet builders n={n_docs}") + sparse_report = export_sparse_graphrag(corpus, out) + extra_manifest["sparse"] = sparse_report + with open(spill / "vectors.pkl", "rb") as _vf: + import pickle as _pickle + + vectors = _pickle.load(_vf) + dummy_bm25 = { + "documents": pd.DataFrame(), + "postings": pd.DataFrame(), + "stats": (sparse_report.get("bm25") or {}).get("bm25") + or (sparse_report.get("bm25") or {}), + } + dummy_graph = { + "nodes": pd.DataFrame(), + "edges": pd.DataFrame(), + "incoming": pd.DataFrame(), + "outgoing": pd.DataFrame(), + "stats": sparse_report.get("graph") or {}, + } + code_root = Path(__file__).resolve().parent.parent + manifest = package_release( + out, + corpus, + dummy_bm25, + dummy_graph, + vectors, + source_meta, + country, + code_root, + normalization_report=norm_report, + extra_manifest=extra_manifest, + wipe=False, + skip_bm25_graph=True, + ) + del corpus, vectors + gc.collect() + _log(f"packaged {out}") + result = { + "country": country["slug"], + "source": repo, + "source_revision": source_meta["source_revision"], + "out": str(out), + "target_hub_id": target_repo(country["slug"]), + "counts": manifest["counts"], + "normalization": norm_report, + "vector_blocker": vector_blocker, + "neighbor_via": neighbor_via, + "schema_version": manifest["schema_version"], + "skipped": False, + "incremental": extra_manifest["incremental"], + } + if upload: + from .upload import upload_release + + hub = upload_release(out, target_repo(country["slug"])) + result["hub"] = hub + _log(f"uploaded {hub['url']} rev={hub['revision']}") + record_progress({"event": "uploaded", **result}) + else: + record_progress({"event": "built_local", **{k: v for k, v in result.items() if k != "normalization"}}) + return result + + +def batch( + slugs: list[str] | None = None, + upload: bool = False, + skip_done: bool = True, + mode: str = "auto", + force: bool = False, + skip_vectors: bool = False, +) -> list[dict[str, Any]]: + """Build every indexable country. Unchanged Hub revisions are skipped in auto mode. + + ``skip_done`` is kept for compatibility: it no longer skips a country whose + source revision changed. Pass ``force=True`` (or ``--no-skip-done``) to + rebuild regardless of CID overlap. + """ + targets = slugs or [c["slug"] for c in indexable_countries()] + if "malta" in targets: + targets = ["malta"] + [s for s in targets if s != "malta"] + results = [] + rebuild_force = force or not skip_done + for slug in targets: + try: + results.append( + build_country( + slug, + upload=upload, + mode=mode, + force=rebuild_force, + skip_vectors=skip_vectors, + ) + ) + except Exception as exc: + _log(f"FAILED {slug}: {exc}") + record_progress( + { + "event": "failed", + "country": slug, + "error": str(exc), + "traceback": traceback.format_exc(), + } + ) + continue + return results + + +def reindex_from_gaps( + *, + upload: bool = False, + slugs: list[str] | None = None, + limit: int | None = None, + max_corpus_rows: int | None = 20_000, + skip_vectors: bool = False, + workers: int = 4, + mode: str = "auto", + force: bool = False, + all_indexable: bool = False, + device: str = "cuda", +) -> list[dict[str, Any]]: + """Rebuild country IR. Default is Hub gaps; ``all_indexable`` processes every catalog country. + + Default cap skips huge corpora (Finland, Dominican Republic). Pass + ``max_corpus_rows=None`` to include them. + """ + from .catalog import indexable_countries + from .coverage import gap_report + + if slugs is None: + if all_indexable: + rows = [{"slug": c["slug"], "corpus_rows": 0} for c in indexable_countries()] + _log(f"reindex all indexable n={len(rows)}") + else: + report = gap_report(workers=workers) + rows = [c for c in report["countries"] if c.get("rebuild")] + _log( + f"reindex targets n={len(rows)} " + f"(from scan rebuild={len(report.get('rebuild') or [])})" + ) + rows.sort(key=lambda r: int(r.get("corpus_rows") or 0)) + if max_corpus_rows is not None: + rows = [ + r + for r in rows + if int(r.get("corpus_rows") or 0) <= int(max_corpus_rows) + ] + if limit is not None: + rows = rows[: int(limit)] + slugs = [str(r["slug"]) for r in rows] + kwargs = { + "upload": upload, + "mode": mode, + "force": force, + "skip_vectors": skip_vectors, + "fetch_hub_prior_ir": True, + "device": device, + } + n_workers = max(1, int(workers or 1)) + _log(f"reindex parallel workers={n_workers} countries={len(slugs)} device=cuda") + import multiprocessing as mp + from concurrent.futures import ProcessPoolExecutor, as_completed + + try: + mp.set_start_method("spawn", force=False) + except RuntimeError: + pass + + results = [None] * len(slugs) + with ProcessPoolExecutor(max_workers=n_workers, max_tasks_per_child=1) as pool: + futs = { + pool.submit(_reindex_one_country, (slug, kwargs)): i + for i, slug in enumerate(slugs) + } + for fut in as_completed(futs): + idx = futs[fut] + slug = slugs[idx] + try: + results[idx] = fut.result() + except Exception as exc: + _log(f"FAILED {slug}: {exc}") + results[idx] = {"country": slug, "skipped": False, "error": str(exc)} + return [r for r in results if r is not None] + + +def _reindex_one_country(item: tuple[str, dict[str, Any]]) -> dict[str, Any]: + slug, kwargs = item + _log(f"reindex start {slug}") + try: + return build_country(slug, **kwargs) + except Exception as exc: + _log(f"FAILED {slug}: {exc}") + record_progress( + { + "event": "failed", + "country": slug, + "error": str(exc), + "traceback": traceback.format_exc(), + } + ) + return {"country": slug, "skipped": False, "error": str(exc)} diff --git a/country_laws_ir/__init__.py b/country_laws_ir/__init__.py index cb97e439ac1cd1646bbaa3943b7b61b3fa3b124f..35db2f270ce51a1cb5b90306650e116f8f4aa343 100644 --- a/country_laws_ir/__init__.py +++ b/country_laws_ir/__init__.py @@ -1,6 +1,6 @@ """Country-law CID-keyed sparse GraphRAG packager (SkillCenter / publicus-ir family).""" -__version__ = "0.3.0" +__version__ = "0.5.0" # Layout matches SkillCenter HF release / publicus-ir family; schema string is domain-specific. SCHEMA_VERSION = "country-laws-ir-graphrag/v1" LAYOUT_FAMILY = "skillcenter-huggingface-release/v3" diff --git a/country_laws_ir/__main__.py b/country_laws_ir/__main__.py index 419fbb5dde4d0636b7e6c2458ca7df517b72b18c..438bb8d0cca0f061a42ee449d414a2ff2c0383cf 100644 --- a/country_laws_ir/__main__.py +++ b/country_laws_ir/__main__.py @@ -1,4 +1,4 @@ -"""python -m country_laws_ir {build,query,batch,catalog}""" +"""python -m country_laws_ir {build,query,batch,catalog,normalize,package-raw}""" from __future__ import annotations @@ -14,17 +14,29 @@ def main(argv: list[str] | None = None) -> int: p_build = sub.add_parser("build") p_build.add_argument("--source-repo", "--source", dest="source", default="malta", - help="Hub dataset id (endomorphosis/ipfs__laws) or country slug") + help="Hub dataset id (endomorphosis/ipfs__laws), country slug, or local pack dir") p_build.add_argument("--out", default=None) - p_build.add_argument("--device", default="cpu") + p_build.add_argument( + "--device", + default="cuda", + help="Embedding device (cuda by default, like US Code / Open US Law; falls back to cpu)", + ) p_build.add_argument("--neighbor-k", type=int, default=8) p_build.add_argument("--skip-vectors", action="store_true") - p_build.add_argument("--upload", action="store_true") + p_build.add_argument("--upload", action="store_true", + help="Publish the packaged release to justicedao/ipfs__laws_ir (requires HF_TOKEN)") + p_build.add_argument("--mode", default="auto", choices=["auto", "full", "delta"], + help="auto skips unchanged Hub revisions and reuses embeddings by entry_cid") + p_build.add_argument("--force", action="store_true", help="Ignore source fingerprint skip and reuse caches") + p_build.add_argument("--prior-dir", default=None, help="Prior GraphRAG release to delta against") p_batch = sub.add_parser("batch") p_batch.add_argument("--slugs", nargs="*", default=None) p_batch.add_argument("--upload", action="store_true") - p_batch.add_argument("--no-skip-done", action="store_true") + p_batch.add_argument("--no-skip-done", action="store_true", + help="Force a full rebuild of every country (ignore unchanged fingerprints)") + p_batch.add_argument("--mode", default="auto", choices=["auto", "full", "delta"]) + p_batch.add_argument("--skip-vectors", action="store_true") p_q = sub.add_parser("query") p_q.add_argument("--local-dir", required=True) @@ -34,7 +46,52 @@ def main(argv: list[str] | None = None) -> int: p_norm.add_argument("--source-repo", "--source", dest="source", default="malta") p_norm.add_argument("--out", default=None, help="Optional JSON report path") - sub.add_parser("catalog") + p_cat = sub.add_parser("catalog") + p_cat.add_argument("--refresh", action="store_true", + help="List public endomorphosis/ipfs_*_laws datasets and persist new slugs") + + p_cov = sub.add_parser("coverage", help="Compare endomorphosis sources vs justicedao GraphRAG releases") + p_cov.add_argument("--gaps", action="store_true", + help="Scan Hub for missing, stale, and incomplete IR (downloads manifests)") + p_cov.add_argument("--workers", type=int, default=8) + + p_re = sub.add_parser( + "reindex", + help="Scan endomorphosis vs justicedao and incrementally rebuild stale/missing IR", + ) + p_re.add_argument("--upload", action="store_true", + help="Publish rebuilt packs to justicedao (requires HF_TOKEN)") + p_re.add_argument("--slugs", nargs="*", default=None) + p_re.add_argument("--limit", type=int, default=None) + p_re.add_argument("--max-corpus-rows", type=int, default=20000, + help="Skip IR larger than this many rows (0 = no cap)") + p_re.add_argument("--skip-vectors", action="store_true") + p_re.add_argument("--workers", type=int, default=2, + help="Parallel country workers (default 2 to stay under MemAbort; CUDA encodes are file-locked)") + p_re.add_argument("--device", default="cuda") + p_re.add_argument("--mode", default="auto", choices=["auto", "full", "delta"]) + p_re.add_argument("--all", action="store_true", + help="Process every indexable catalog country (not only Hub gaps)") + p_re.add_argument("--force", action="store_true", + help="Rebuild even when the source SHA matches (rerun normalize/verifiers)") + + p_ver = sub.add_parser( + "verify", + help="Normalize a country pack and run admission verifiers (no GraphRAG)", + ) + p_ver.add_argument("--source-repo", "--source", dest="source", default=None) + p_ver.add_argument("--all", action="store_true", help="Verify every indexable catalog country") + p_ver.add_argument("--limit", type=int, default=None) + + p_raw = sub.add_parser("package-raw") + p_raw.add_argument("--slug", required=True, help="Country slug used in justicedao/ipfs__laws_ir") + p_raw.add_argument("--instruments-dir", default=None, + help="Collector JSON directory (default: $LEGAL_CORPORA_ROOT//instruments)") + p_raw.add_argument("--iso", default=None, help="Collector ISO directory name if different from slug") + p_raw.add_argument("--out", default=None, help="Local pack directory (laws.parquet + pack_meta.json)") + p_raw.add_argument("--source-dataset", default=None, + help="Raw Hub id (default endomorphosis/ipfs__laws)") + p_raw.add_argument("--prior-pack", default=None, help="Existing parquet pack to merge into") args = ap.parse_args(argv) if args.cmd == "build": @@ -47,6 +104,9 @@ def main(argv: list[str] | None = None) -> int: device=args.device, neighbor_k=args.neighbor_k, skip_vectors=args.skip_vectors, + mode=args.mode, + force=args.force, + prior_dir=Path(args.prior_dir) if args.prior_dir else None, ) print(json.dumps({k: result[k] for k in result if k != "normalization"}, indent=2, default=str)) print(json.dumps({"normalization": result["normalization"]}, indent=2, default=str)) @@ -54,8 +114,17 @@ def main(argv: list[str] | None = None) -> int: if args.cmd == "batch": from .build import batch - results = batch(slugs=args.slugs, upload=args.upload, skip_done=not args.no_skip_done) - print(json.dumps([{"country": r["country"], "out": r["out"]} for r in results], indent=2)) + results = batch( + slugs=args.slugs, + upload=args.upload, + skip_done=not args.no_skip_done, + mode=args.mode, + skip_vectors=args.skip_vectors, + ) + print(json.dumps( + [{"country": r["country"], "out": r["out"], "skipped": r.get("skipped", False)} for r in results], + indent=2, + )) return 0 if args.cmd == "query": from .query import main as qmain @@ -63,12 +132,13 @@ def main(argv: list[str] | None = None) -> int: argv2 = ["--local-dir", args.local_dir] + [a for a in args.rest if a != "--"] return qmain(argv2) if args.cmd == "normalize": - from .build import CACHE, REPORTS, ROOT + from .build import CACHE, REPORTS from .catalog import get_country from .normalize import build_corpus, load_source country = get_country(args.source) - laws, articles, source_meta = load_source(country["repo"], CACHE) + local = country.get("local_source_dir") + laws, articles, source_meta = load_source(local or country["repo"], CACHE) corpus, report = build_corpus(laws, articles, source_meta) out = Path(args.out) if args.out else REPORTS / f"{country['slug']}_normalization.json" out.parent.mkdir(parents=True, exist_ok=True) @@ -76,9 +146,131 @@ def main(argv: list[str] | None = None) -> int: print(json.dumps({"out": str(out), "n_out": report["n_out"], "unit": report["unit"], "drops": report["drops"]}, indent=2)) return 0 if args.cmd == "catalog": - from .catalog import COUNTRIES, indexable_countries + from .catalog import all_countries, refresh_from_hub + + countries = refresh_from_hub() if args.refresh else all_countries() + print(json.dumps( + {"n": len(countries), "indexable": len([c for c in countries if c.get("indexable")]), "countries": countries}, + indent=2, + )) + return 0 + if args.cmd == "coverage": + from .coverage import coverage_report, gap_report + + report = gap_report(workers=args.workers) if args.gaps else coverage_report() + print(json.dumps(report, indent=2, default=str)) + return 0 + if args.cmd == "reindex": + from .build import reindex_from_gaps - print(json.dumps({"n": len(COUNTRIES), "indexable": len(indexable_countries()), "countries": COUNTRIES}, indent=2)) + cap = None if args.all or int(args.max_corpus_rows or 0) <= 0 else int(args.max_corpus_rows) + results = reindex_from_gaps( + upload=args.upload, + slugs=args.slugs or None, + limit=args.limit, + max_corpus_rows=cap, + skip_vectors=args.skip_vectors, + workers=args.workers, + mode=args.mode, + force=args.force, + all_indexable=args.all, + device=args.device, + ) + print(json.dumps( + [ + { + "country": r.get("country"), + "skipped": r.get("skipped", False), + "out": r.get("out"), + "hub": (r.get("hub") or {}).get("url") if isinstance(r.get("hub"), dict) else r.get("hub"), + "error": r.get("error"), + "kind": (r.get("incremental") or {}).get("kind"), + "n_added": ((r.get("incremental") or {}).get("delta") or {}).get("n_added"), + "n_unchanged": ((r.get("incremental") or {}).get("delta") or {}).get("n_unchanged"), + } + for r in results + ], + indent=2, + default=str, + )) + return 1 if any(r.get("error") for r in results) else 0 + if args.cmd == "verify": + from .catalog import indexable_countries + from .verify import verify_source + + slugs = [] + if args.all: + slugs = [c["slug"] for c in indexable_countries()] + if args.limit: + slugs = slugs[: int(args.limit)] + elif args.source: + slugs = [args.source] + else: + print(json.dumps({"error": "pass --source or --all"}, indent=2)) + return 2 + rows = [] + failed = 0 + for slug in slugs: + try: + row = verify_source(slug) + except Exception as exc: + row = {"slug": slug, "error": str(exc), "verification": {"admitted": False}} + rows.append(row) + if not (row.get("verification") or {}).get("admitted", False): + failed += 1 + from collections import Counter + + units = Counter(str(r.get("unit") or "") for r in rows) + mismatch = [] + latin_blocked = [] + for r in rows: + for chk in (r.get("verification") or {}).get("checks") or []: + if chk.get("id") != "heading_language": + continue + ev = chk.get("evidence") or {} + if chk.get("severity") == "fail" and not chk.get("passed"): + latin_blocked.append(r.get("slug")) + if "review samples" in str(chk.get("message") or ""): + mismatch.append( + { + "slug": r.get("slug"), + "document_language": ev.get("document_language"), + "heading_language": ev.get("heading_language"), + } + ) + print( + json.dumps( + { + "n": len(rows), + "n_failed": failed, + "by_unit": dict(units), + "heading_mismatch": mismatch, + "latin_split_blocked": latin_blocked, + "countries": rows, + }, + indent=2, + default=str, + ) + ) + return 1 if failed else 0 + if args.cmd == "package-raw": + from .build import RELEASES + from .raw_package import default_instruments_dir, package_instruments + + instruments = ( + Path(args.instruments_dir) + if args.instruments_dir + else default_instruments_dir(args.iso or args.slug) + ) + out = Path(args.out) if args.out else RELEASES / "raw-packs" / args.slug + meta = package_instruments( + instruments_dir=instruments, + out=out, + slug=args.slug, + source_dataset=args.source_dataset, + prior_pack=Path(args.prior_pack) if args.prior_pack else None, + ) + print(json.dumps(meta, indent=2, default=str)) return 0 return 1 diff --git a/country_laws_ir/auth.py b/country_laws_ir/auth.py index 36e9336012789878e1428b4c22e1af86092403ae..9b29b3788cf870a87958a35a592bd229f5970195 100644 --- a/country_laws_ir/auth.py +++ b/country_laws_ir/auth.py @@ -1,16 +1,38 @@ -"""Public Hugging Face reads only. This pipeline never loads, stores, or uses a token.""" +"""Hugging Face auth helpers. + +Default reads stay anonymous. Gap scans and JusticeDAO uploads may use the +operator token from the Hugging Face cache file or the environment. The token +is never logged. +""" from __future__ import annotations import os +from pathlib import Path def configure_hf() -> None: - """Force anonymous public Hub access. Tokens are ignored, never printed, never stored.""" - os.environ["HF_HUB_DISABLE_IMPLICIT_TOKEN"] = "1" - # Do not read HF_TOKEN / HUGGING_FACE_HUB_TOKEN. Public datasets need no auth. + """Do not implicitly pick up ambient tokens for anonymous public reads.""" + os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1") def public_token() -> bool: """huggingface_hub `token=False` means anonymous (do not pick up env tokens).""" return False + + +def operator_token() -> str | bool: + """Return a token for authenticated Hub reads/writes, or False if none.""" + for key in ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN"): + value = (os.environ.get(key) or "").strip() + if value: + return value + path = Path.home() / ".cache" / "huggingface" / "token" + if path.is_file(): + try: + value = path.read_text(encoding="utf-8").strip() + except OSError: + return False + if value: + return value + return False diff --git a/country_laws_ir/build.py b/country_laws_ir/build.py index 2bfbf08482b470e7187cc6584d5bb448b235d5df..768973af97da5ea96deef2b5b7bbbc06909d9ebe 100644 --- a/country_laws_ir/build.py +++ b/country_laws_ir/build.py @@ -1,7 +1,15 @@ -"""End-to-end build: normalize → BM25 → graph → vectors → package (no upload by default).""" +"""End-to-end build: normalize → incremental vectors → BM25 → graph → package. + +Default mode is ``auto``: skip when the endomorphosis source revision is +unchanged, otherwise delta-refresh embeddings by ``entry_cid`` and rebuild +BM25/graph from the current corpus. Publication to ``justicedao/*`` is opt-in +via ``upload=True``. +""" from __future__ import annotations +import os + import json import pandas as pd @@ -10,25 +18,34 @@ from datetime import datetime, timezone from pathlib import Path from typing import Any -from .bm25 import bm25_neighbors, build_index +from .sparse import export_sparse_graphrag from .mem import MemAbort, checkpoint, log_mem -from .spill import ( - SQLITE_THRESHOLD, - build_bm25_tf_spill, - build_graph_from_neighbor_shards, - neighbors_via_sqlite, - should_use_sqlite, - spill_dir_for, - spill_pickle, -) +from .spill import spill_dir_for, spill_pickle from .package import package_from_spill, package_release from .catalog import get_country, indexable_countries, target_repo -from .graph import build_graph + +from .incremental import ( + fetch_hub_prior, + load_embedding_cache, + load_prior_release, + load_release_vectors_by_cid, + merge_embedding_maps, + plan_rebuild, + save_embedding_cache, +) from .normalize import build_corpus, load_source from .auth import configure_hf -from .vectors import encode_corpus, embeddings_available, layout_stub_vectors, layout_vectors +from .vectors import ( + DIMENSION, + MODEL_NAME, + assemble_embeddings, + embeddings_by_cid, + layout_stub_vectors, + layout_vectors, + select_device, +) -ROOT = Path("/workspace/country-laws-ir") +ROOT = Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(Path.home() / ".ipfs_datasets" / "country-laws-ir"))) CACHE = ROOT / "cache" RELEASES = ROOT / "releases" REPORTS = ROOT / "reports" @@ -43,17 +60,122 @@ def _log(msg: str) -> None: def record_progress(event: dict[str, Any]) -> None: event = dict(event) event.setdefault("ts", datetime.now(timezone.utc).isoformat()) - with PROGRESS.open("a", encoding="utf-8") as f: - f.write(json.dumps(event, ensure_ascii=False) + "\n") + PROGRESS.parent.mkdir(parents=True, exist_ok=True) + lock_path = PROGRESS.with_suffix(".lock") + with lock_path.open("a", encoding="utf-8") as lock_fh: + try: + import fcntl + + fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX) + except Exception: + pass + with PROGRESS.open("a", encoding="utf-8") as f: + f.write(json.dumps(event, ensure_ascii=False) + "\n") + + +def _prior_dir_for( + slug: str, + out: Path, + prior_dir: Path | None, + *, + fetch_hub: bool = True, +) -> Path | None: + if prior_dir is not None: + return Path(prior_dir) + if out.is_dir() and (out / "manifest.json").is_file(): + return out + default = RELEASES / f"ipfs_{slug}_laws_ir" + if default.is_dir() and (default / "manifest.json").is_file() and default.resolve() != out.resolve(): + return default + if not fetch_hub: + return None + hub = fetch_hub_prior(slug, cache_root=CACHE / "hub-ir") + if hub is not None: + _log(f"using justicedao prior {hub}") + return hub + + +def _encode_vectors( + *, + corpus: pd.DataFrame, + country_slug: str, + prior, + plan, + skip_vectors: bool, + device: str, +) -> tuple[dict[str, Any], str | None, dict[str, Any]]: + import gc + + vector_report: dict[str, Any] = {"status": "stub"} + vector_blocker = None + if skip_vectors: + vectors = layout_stub_vectors(corpus, reason="skip_vectors flag") + return vectors, "skip_vectors", {"status": "stub", "reason": "skip_vectors"} + + cid_cache_path = CACHE / "embeddings" / f"{country_slug}_by_cid.parquet" + prior_by_cid = {} + if plan.reuse_embeddings: + prior_by_cid = merge_embedding_maps( + load_embedding_cache(cid_cache_path), + None if prior is None else load_release_vectors_by_cid(prior.directory), + ) + _log(f"embedding cache reused_cids={len(prior_by_cid)}") + try: + positional = CACHE / "embeddings" / f"{country_slug}.npy" + resolved, fallback = select_device(device) + if fallback: + _log(f"embedding device fallback requested={device} using={resolved}") + embeddings, vector_report = assemble_embeddings( + corpus, + prior_by_cid, + encode_missing=True, + device=resolved, + checkpoint_path=str(positional), + ) + if ( + vector_report.get("status") in {"stub_missing_encoder", "incomplete"} + and not int(vector_report.get("n_reused") or 0) + ): + vector_blocker = vector_report.get("reason") or vector_report.get("status") + vectors = layout_stub_vectors(corpus, reason=str(vector_blocker)) + return vectors, vector_blocker, vector_report + vectors = layout_vectors(corpus, embeddings) + if int(vector_report.get("n_reused") or 0) and vector_report.get("status") != "reused": + vectors["stats"]["status"] = "partial" + vectors["stats"]["n_reused"] = int(vector_report.get("n_reused") or 0) + vectors["stats"]["n_missing"] = int(vector_report.get("n_missing") or 0) + vector_blocker = vector_report.get("reason") or vector_report.get("status") + save_embedding_cache( + cid_cache_path, + merge_embedding_maps(prior_by_cid, embeddings_by_cid(corpus, embeddings)), + model_name=MODEL_NAME, + dimension=DIMENSION, + ) + del embeddings + gc.collect() + _log( + f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']} " + f"reused={vector_report.get('n_reused')} encoded={vector_report.get('n_encoded')}" + ) + return vectors, None, vector_report + except Exception as exc: + vector_blocker = f"embedding_failed: {exc}" + _log(f"vector embedding failed; writing stub ({exc})") + vectors = layout_stub_vectors(corpus, reason=vector_blocker) + return vectors, vector_blocker, {"status": "failed", "reason": str(exc)} def build_country( source: str, out: Path | None = None, upload: bool = False, - device: str = "cpu", + device: str = "cuda", neighbor_k: int = 8, skip_vectors: bool = False, + mode: str = "auto", + force: bool = False, + prior_dir: Path | None = None, + fetch_hub_prior_ir: bool = True, ) -> dict[str, Any]: country = get_country(source) if not country.get("indexable", True): @@ -69,7 +191,9 @@ def build_country( ) else None ) - _log(f"build start {repo} -> {out} (upload={upload}) local={local_dir}") + _log( + f"build start {repo} -> {out} (upload={upload} mode={mode} force={force}) local={local_dir}" + ) configure_hf() CACHE.mkdir(parents=True, exist_ok=True) REPORTS.mkdir(parents=True, exist_ok=True) @@ -78,6 +202,39 @@ def build_country( f"source loaded laws={source_meta['n_laws_source']} " f"articles={source_meta['n_articles_source']} rev={source_meta['source_revision']}" ) + prior = load_prior_release( + _prior_dir_for( + country["slug"], + out, + prior_dir, + fetch_hub=fetch_hub_prior_ir, + ) + ) + plan = plan_rebuild( + mode=mode, + source_meta=source_meta, + prior=prior, + force=force, + rebuild_stub_vectors=not skip_vectors, + ) + if plan.skip_build: + _log(f"skip unchanged {country['slug']} rev={plan.source_revision}") + result = { + "country": country["slug"], + "source": repo, + "source_revision": source_meta["source_revision"], + "out": str(out), + "target_hub_id": target_repo(country["slug"]), + "skipped": True, + "incremental": plan.to_dict(), + "normalization": {"n_out": plan.delta.current_count if plan.delta else 0}, + "vector_blocker": None, + "neighbor_via": None, + "schema_version": "country-laws-ir-graphrag/v1", + } + record_progress({"event": "skipped_unchanged", **{k: v for k, v in result.items() if k != "normalization"}}) + return result + corpus, norm_report = build_corpus(laws, articles, source_meta) report_path = REPORTS / f"{country['slug']}_normalization.json" report_path.write_text(json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") @@ -90,9 +247,30 @@ def build_country( ) if corpus.empty: raise RuntimeError("Normalized corpus is empty; refusing to package") + verdict = (norm_report or {}).get("verification") or {} + if verdict.get("blocks_graphrag") and not force: + from .verify import NormalizationAdmissionError + + raise NormalizationAdmissionError( + f"{country['slug']} failed normalization verifiers: {verdict.get('failed_ids')}" + ) import gc + plan = plan_rebuild( + mode=mode, + source_meta=source_meta, + prior=prior, + current_corpus=corpus, + force=force, + rebuild_stub_vectors=not skip_vectors, + ) + _log( + f"rebuild kind={plan.kind.value} reuse_embeddings={plan.reuse_embeddings} " + f"added={0 if plan.delta is None else plan.delta.n_added} " + f"removed={0 if plan.delta is None else plan.delta.n_removed}" + ) + n_docs = len(corpus) spill = spill_dir_for(country["slug"], CACHE) spill.mkdir(parents=True, exist_ok=True) @@ -100,81 +278,63 @@ def build_country( corpus.to_parquet(corpus_ckpt, index=False) checkpoint("after_normalize", log=_log) - vector_blocker = None - if skip_vectors: - vectors = layout_stub_vectors(corpus, reason="skip_vectors flag") - vector_blocker = "skip_vectors" - spill_pickle(spill / "vectors.pkl", vectors) - del vectors - gc.collect() - elif embeddings_available(): - try: - ckpt = CACHE / "embeddings" / f"{country['slug']}.npy" - _log(f"vectors encode start n={n_docs} checkpoint={ckpt}") - embeddings = encode_corpus(corpus, device=device, checkpoint_path=str(ckpt)) - vectors = layout_vectors(corpus, embeddings) - _log(f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']}") - spill_pickle(spill / "vectors.pkl", vectors) - del embeddings, vectors - gc.collect() - checkpoint("vectors_spilled", log=_log) - except Exception as exc: - vector_blocker = f"embedding_failed: {exc}" - _log(f"vector embedding failed; writing stub ({exc})") - vectors = layout_stub_vectors(corpus, reason=vector_blocker) - spill_pickle(spill / "vectors.pkl", vectors) - del vectors - gc.collect() - else: - vector_blocker = "sentence-transformers/torch unavailable" - _log(f"vectors stub: {vector_blocker}") - vectors = layout_stub_vectors(corpus, reason=vector_blocker) - spill_pickle(spill / "vectors.pkl", vectors) - del vectors - gc.collect() + vectors, vector_blocker, vector_report = _encode_vectors( + corpus=corpus, + country_slug=country["slug"], + prior=prior, + plan=plan, + skip_vectors=skip_vectors, + device=device, + ) + spill_pickle(spill / "vectors.pkl", vectors) + del vectors + gc.collect() + checkpoint("vectors_spilled", log=_log) + extra_manifest = {"incremental": {**plan.to_dict(), "vectors": vector_report}} - use_sqlite = should_use_sqlite(n_docs) - neighbor_via = "stock" - if use_sqlite: - _log(f"sqlite neighbors path n={n_docs} (>= {SQLITE_THRESHOLD}) spill={spill}") - # Free corpus body for neighbor stream — reload later for graph - del corpus - gc.collect() - neighbors_via_sqlite(corpus_ckpt, spill, n_docs, k=neighbor_k, log=_log) - neighbor_via = "sqlite_fts" - bm25_info = build_bm25_tf_spill(corpus_ckpt, spill, n_docs, log=_log) - corpus = pd.read_parquet(corpus_ckpt) - graph = build_graph_from_neighbor_shards(corpus, spill, log=_log) - spill_pickle(spill / "graph.pkl", graph) - del graph, corpus - gc.collect() - checkpoint("graph_spilled", log=_log) - code_root = Path(__file__).resolve().parent.parent - manifest = package_from_spill( - out, spill, corpus_ckpt, source_meta, country, code_root, - normalization_report=norm_report, expected_rows=n_docs, - ) - _log(f"packaged sequential via={neighbor_via} {out}") - else: - bm25 = build_index(corpus) - _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}") - _log(f"bm25 neighbors start n={n_docs} k={neighbor_k}") - neighbors = bm25_neighbors(bm25, k=neighbor_k) - _log("bm25 neighbors done") - graph = build_graph(corpus, neighbors) - del neighbors - gc.collect() - _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}") - with open(spill / "vectors.pkl", "rb") as _vf: - import pickle as _pickle - vectors = _pickle.load(_vf) - code_root = Path(__file__).resolve().parent.parent - manifest = package_release( - out, corpus, bm25, graph, vectors, source_meta, country, code_root, - normalization_report=norm_report, - ) - del corpus, bm25, graph, vectors - gc.collect() + neighbor_via = "hf_graphrag" + if out.exists(): + import shutil as _shutil + + _shutil.rmtree(out) + out.mkdir(parents=True, exist_ok=True) + _log(f"sparse GraphRAG via hf_graphrag.bm25/graph parquet builders n={n_docs}") + sparse_report = export_sparse_graphrag(corpus, out) + extra_manifest["sparse"] = sparse_report + with open(spill / "vectors.pkl", "rb") as _vf: + import pickle as _pickle + + vectors = _pickle.load(_vf) + dummy_bm25 = { + "documents": pd.DataFrame(), + "postings": pd.DataFrame(), + "stats": (sparse_report.get("bm25") or {}).get("bm25") + or (sparse_report.get("bm25") or {}), + } + dummy_graph = { + "nodes": pd.DataFrame(), + "edges": pd.DataFrame(), + "incoming": pd.DataFrame(), + "outgoing": pd.DataFrame(), + "stats": sparse_report.get("graph") or {}, + } + code_root = Path(__file__).resolve().parent.parent + manifest = package_release( + out, + corpus, + dummy_bm25, + dummy_graph, + vectors, + source_meta, + country, + code_root, + normalization_report=norm_report, + extra_manifest=extra_manifest, + wipe=False, + skip_bm25_graph=True, + ) + del corpus, vectors + gc.collect() _log(f"packaged {out}") result = { "country": country["slug"], @@ -187,6 +347,8 @@ def build_country( "vector_blocker": vector_blocker, "neighbor_via": neighbor_via, "schema_version": manifest["schema_version"], + "skipped": False, + "incremental": extra_manifest["incremental"], } if upload: from .upload import upload_release @@ -204,25 +366,32 @@ def batch( slugs: list[str] | None = None, upload: bool = False, skip_done: bool = True, + mode: str = "auto", + force: bool = False, + skip_vectors: bool = False, ) -> list[dict[str, Any]]: - done = set() - if skip_done and PROGRESS.exists(): - for line in PROGRESS.read_text(encoding="utf-8").splitlines(): - if not line.strip(): - continue - rec = json.loads(line) - if rec.get("event") in {"uploaded", "built_local"} and rec.get("country"): - done.add(rec["country"]) + """Build every indexable country. Unchanged Hub revisions are skipped in auto mode. + + ``skip_done`` is kept for compatibility: it no longer skips a country whose + source revision changed. Pass ``force=True`` (or ``--no-skip-done``) to + rebuild regardless of CID overlap. + """ targets = slugs or [c["slug"] for c in indexable_countries()] if "malta" in targets: targets = ["malta"] + [s for s in targets if s != "malta"] results = [] + rebuild_force = force or not skip_done for slug in targets: - if skip_done and slug in done: - _log(f"skip already done {slug}") - continue try: - results.append(build_country(slug, upload=upload)) + results.append( + build_country( + slug, + upload=upload, + mode=mode, + force=rebuild_force, + skip_vectors=skip_vectors, + ) + ) except Exception as exc: _log(f"FAILED {slug}: {exc}") record_progress( @@ -235,3 +404,98 @@ def batch( ) continue return results + + +def reindex_from_gaps( + *, + upload: bool = False, + slugs: list[str] | None = None, + limit: int | None = None, + max_corpus_rows: int | None = 20_000, + skip_vectors: bool = False, + workers: int = 4, + mode: str = "auto", + force: bool = False, + all_indexable: bool = False, + device: str = "cuda", +) -> list[dict[str, Any]]: + """Rebuild country IR. Default is Hub gaps; ``all_indexable`` processes every catalog country. + + Default cap skips huge corpora (Finland, Dominican Republic). Pass + ``max_corpus_rows=None`` to include them. + """ + from .catalog import indexable_countries + from .coverage import gap_report + + if slugs is None: + if all_indexable: + rows = [{"slug": c["slug"], "corpus_rows": 0} for c in indexable_countries()] + _log(f"reindex all indexable n={len(rows)}") + else: + report = gap_report(workers=workers) + rows = [c for c in report["countries"] if c.get("rebuild")] + _log( + f"reindex targets n={len(rows)} " + f"(from scan rebuild={len(report.get('rebuild') or [])})" + ) + rows.sort(key=lambda r: int(r.get("corpus_rows") or 0)) + if max_corpus_rows is not None: + rows = [ + r + for r in rows + if int(r.get("corpus_rows") or 0) <= int(max_corpus_rows) + ] + if limit is not None: + rows = rows[: int(limit)] + slugs = [str(r["slug"]) for r in rows] + kwargs = { + "upload": upload, + "mode": mode, + "force": force, + "skip_vectors": skip_vectors, + "fetch_hub_prior_ir": True, + "device": device, + } + n_workers = max(1, int(workers or 1)) + _log(f"reindex parallel workers={n_workers} countries={len(slugs)} device=cuda") + import multiprocessing as mp + from concurrent.futures import ProcessPoolExecutor, as_completed + + try: + mp.set_start_method("spawn", force=False) + except RuntimeError: + pass + + results = [None] * len(slugs) + with ProcessPoolExecutor(max_workers=n_workers, max_tasks_per_child=1) as pool: + futs = { + pool.submit(_reindex_one_country, (slug, kwargs)): i + for i, slug in enumerate(slugs) + } + for fut in as_completed(futs): + idx = futs[fut] + slug = slugs[idx] + try: + results[idx] = fut.result() + except Exception as exc: + _log(f"FAILED {slug}: {exc}") + results[idx] = {"country": slug, "skipped": False, "error": str(exc)} + return [r for r in results if r is not None] + + +def _reindex_one_country(item: tuple[str, dict[str, Any]]) -> dict[str, Any]: + slug, kwargs = item + _log(f"reindex start {slug}") + try: + return build_country(slug, **kwargs) + except Exception as exc: + _log(f"FAILED {slug}: {exc}") + record_progress( + { + "event": "failed", + "country": slug, + "error": str(exc), + "traceback": traceback.format_exc(), + } + ) + return {"country": slug, "skipped": False, "error": str(exc)} diff --git a/country_laws_ir/catalog.py b/country_laws_ir/catalog.py index d4352954caaa28b441485d76ce2b8a8f5ae92ec8..848143231166ea442bbc43d0c3d6bb11b4603f15 100644 --- a/country_laws_ir/catalog.py +++ b/country_laws_ir/catalog.py @@ -2,15 +2,39 @@ Belgium, Portugal, and Lithuania are incomplete Wayback harvests and are excluded from indexing. american_municipal_law is out of scope. + +The static ``COUNTRIES`` list is the fail-closed baseline. ``refresh_from_hub`` +persists a sidecar cache of newly listed Hub datasets so incremental scrapes +of additional jurisdictions are indexable without a code change. """ from __future__ import annotations +import json +import os +from pathlib import Path from typing import Any -EXCLUDED_SLUGS = {"belgium", "portugal", "lithuania"} +EXCLUDED_SLUGS = {"belgium", "portugal", "lithuania", "ghana"} EXCLUDED_REPOS = {f"endomorphosis/ipfs_{s}_laws" for s in EXCLUDED_SLUGS} +_SKIP_REASONS = { + "belgium": "incomplete Wayback harvest (Justel / Moniteur belge archive shard)", + "portugal": "incomplete Wayback harvest (Diário da República archive shard)", + "lithuania": "incomplete Wayback harvest (e-TAR archive shard)", + "ghana": "thin scrape; Act PDF path blocked by robots", +} + + +def catalog_cache_path() -> Path: + root = Path( + os.environ.get( + "COUNTRY_LAWS_IR_ROOT", + str(Path.home() / ".ipfs_datasets" / "country-laws-ir"), + ) + ) + return root / "catalog_cache.json" + # Hub listing as of 2026-09-03. Refresh via `python -m country_laws_ir catalog --refresh`. COUNTRIES: list[dict[str, Any]] = [ {"slug": "argentina", "repo": "endomorphosis/ipfs_argentina_laws", "name": "Argentina", "indexable": True}, @@ -88,6 +112,54 @@ COUNTRIES: list[dict[str, Any]] = [ ] +def load_cached_countries() -> list[dict[str, Any]]: + path = catalog_cache_path() + if not path.is_file(): + return [] + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except Exception: + return [] + rows = payload.get("countries") if isinstance(payload, dict) else payload + if not isinstance(rows, list): + return [] + out: list[dict[str, Any]] = [] + for row in rows: + if isinstance(row, dict) and row.get("slug") and row.get("repo"): + out.append(dict(row)) + return out + + +def persist_catalog(countries: list[dict[str, Any]], path: Path | None = None) -> Path: + dest = path or catalog_cache_path() + dest.parent.mkdir(parents=True, exist_ok=True) + payload = { + "n": len(countries), + "indexable": sum(1 for c in countries if c.get("indexable")), + "countries": countries, + } + dest.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + return dest + + +def merge_country_rows( + baseline: list[dict[str, Any]], + extra: list[dict[str, Any]], +) -> list[dict[str, Any]]: + """Static catalog wins on slug; Hub extras fill gaps.""" + by_slug = {str(row["slug"]): dict(row) for row in baseline if row.get("slug")} + for row in extra: + slug = str(row.get("slug") or "") + if not slug or slug in by_slug: + continue + by_slug[slug] = dict(row) + return [by_slug[k] for k in sorted(by_slug)] + + +def all_countries() -> list[dict[str, Any]]: + return merge_country_rows(COUNTRIES, load_cached_countries()) + + def get_country(source: str) -> dict[str, Any]: source = source.strip() # Local filtered pack: directory with data/laws.parquet (+ optional pack_meta.json) @@ -133,7 +205,7 @@ def get_country(source: str) -> dict[str, Any]: if "/" in source: slug = source.rsplit("/", 1)[-1] slug = slug.removeprefix("ipfs_").removesuffix("_laws").removesuffix("-ir") - for row in COUNTRIES: + for row in all_countries(): if row["slug"] == slug or row["repo"] == source or row["repo"].endswith("/" + source): return dict(row) if source.startswith("endomorphosis/ipfs_") and source.endswith("_laws"): @@ -143,20 +215,20 @@ def get_country(source: str) -> dict[str, Any]: "repo": source, "name": inferred.replace("_", " ").title(), "indexable": inferred not in EXCLUDED_SLUGS, - "skip_reason": "incomplete Wayback harvest" if inferred in EXCLUDED_SLUGS else None, + "skip_reason": _SKIP_REASONS.get(inferred), } raise KeyError(f"Unknown country-law source: {source}") def indexable_countries() -> list[dict[str, Any]]: - return [c for c in COUNTRIES if c.get("indexable")] + return [c for c in all_countries() if c.get("indexable")] def target_repo(slug: str) -> str: return f"justicedao/ipfs_{slug}_laws_ir" -def refresh_from_hub() -> list[dict[str, Any]]: +def refresh_from_hub(*, persist: bool = True) -> list[dict[str, Any]]: """Anonymous Hub listing of public endomorphosis/ipfs_*_laws datasets.""" from huggingface_hub import HfApi @@ -175,9 +247,10 @@ def refresh_from_hub() -> list[dict[str, Any]]: "repo": ds_id, "name": slug.replace("_", " ").title(), "indexable": slug not in EXCLUDED_SLUGS, - "skip_reason": ( - "incomplete Wayback harvest" if slug in EXCLUDED_SLUGS else None - ), + "skip_reason": _SKIP_REASONS.get(slug), }) found.sort(key=lambda r: r["slug"]) - return found + merged = merge_country_rows(COUNTRIES, found) + if persist: + persist_catalog(merged) + return merged diff --git a/country_laws_ir/cidutil.py b/country_laws_ir/cidutil.py index e9ace7c381c76685dbdb4bab8a75791711e8e27e..f6e13daa170a5b874d50d4539ad1817565fdd0e9 100644 --- a/country_laws_ir/cidutil.py +++ b/country_laws_ir/cidutil.py @@ -59,6 +59,27 @@ def cid_v1_raw_sha256(data: bytes) -> str: return "b" + _b32encode(cid_bytes) +def sha256_key_to_cidv1(value: str) -> str: + """Turn a bare/prefixed SHA-256 routing key into ``bafkrei…`` CIDv1. + + GraphRAG locators must not use hex digests as ``entry_cid`` / ``node_cid``. + """ + + text = str(value or "").strip() + if text.startswith("bafkrei"): + return text + hex_part = text[7:71] if text.lower().startswith("sha256:") else text[:64] + rest = text[71:] if text.lower().startswith("sha256:") else text[64:] + if len(hex_part) != 64: + return text + try: + digest = bytes.fromhex(hex_part) + except ValueError: + return text + cid_bytes = bytes([0x01, 0x55, 0x12, 0x20]) + digest + return "b" + _b32encode(cid_bytes) + rest + + def cid_of_json(obj: Any) -> str: return cid_v1_raw_sha256(canonical_json_bytes(obj)) diff --git a/country_laws_ir/coverage.py b/country_laws_ir/coverage.py new file mode 100644 index 0000000000000000000000000000000000000000..380d7fda93c8d35799efb1997f13847eec6ea3aa --- /dev/null +++ b/country_laws_ir/coverage.py @@ -0,0 +1,455 @@ +"""Compare endomorphosis raw sources against justicedao GraphRAG releases. + +Gap kinds +--------- +* missing — no JusticeDAO IR (and no local pack) +* unpublished — local IR exists, Hub IR does not +* stale — Hub/local IR source revision does not match current endomorphosis SHA +* incomplete — missing corpus/BM25/graph, empty corpus, or source has no laws +* stub_vectors — IR is otherwise current but embeddings were stubbed +""" + +from __future__ import annotations + +import json +import time +from concurrent.futures import ThreadPoolExecutor, as_completed +from pathlib import Path +from typing import Any, Mapping + +from .catalog import EXCLUDED_SLUGS, all_countries, target_repo + +ALIAS_TO_CANONICAL = { + "dominican_republic": "dominicanrepublic", + "el_salvador": "elsalvador", + "north_korea": "northkorea", + "papua_new_guinea": "papuanewguinea", + "san_marino": "sanmarino", + "trinidad_and_tobago": "trinidad", +} + + +def _slug_from_source(dataset_id: str) -> str | None: + if not dataset_id.startswith("endomorphosis/ipfs_") or not dataset_id.endswith("_laws"): + return None + return dataset_id.split("ipfs_", 1)[1].removesuffix("_laws") + + +def _slug_from_ir(dataset_id: str) -> str | None: + if not dataset_id.startswith("justicedao/ipfs_") or not dataset_id.endswith("_laws_ir"): + return None + return dataset_id.split("ipfs_", 1)[1].removesuffix("_laws_ir") + + +def canonical_slug(slug: str) -> str: + return ALIAS_TO_CANONICAL.get(slug, slug) + + +def list_hub_slugs(*, author: str, kind: str) -> list[str]: + from huggingface_hub import HfApi + + from .auth import configure_hf, operator_token, public_token + + configure_hf() + token = operator_token() or public_token() + api = HfApi(token=token) + out: list[str] = [] + for ds in api.list_datasets(author=author): + slug = _slug_from_source(ds.id) if kind == "source" else _slug_from_ir(ds.id) + if slug: + out.append(slug) + return sorted(set(out)) + + +def local_release_slugs(releases_dir: Path) -> list[str]: + if not releases_dir.is_dir(): + return [] + found: list[str] = [] + for path in sorted(releases_dir.glob("ipfs_*_laws_ir")): + if (path / "manifest.json").is_file(): + slug = path.name.removeprefix("ipfs_").removesuffix("_laws_ir") + found.append(slug) + return found + + +IR_FAMILY_PREFIXES = ( + ("data/corpus/", "ir_missing_corpus"), + ("data/bm25/", "ir_missing_bm25"), + ("data/graph/", "ir_missing_graph"), +) +STUB_VECTOR_STATUSES = {"stub", "stub_missing_encoder", "incomplete"} +TINY_LAWS_BYTES = 1024 + + +def classify_gap( + *, + excluded: bool = False, + alias: bool = False, + source_has_laws: bool = True, + source_laws_bytes: int | None = None, + source_revision: str | None = None, + ir_files: list[str] | None = None, + ir_source_revision: str | None = None, + ir_corpus_rows: int | None = None, + vector_status: str | None = None, + local_only: bool = False, + local_source_revision: str | None = None, +) -> dict[str, Any]: + """Pure classifier for missing / stale / incomplete country IR.""" + issues: list[str] = [] + if alias: + return {"status": "alias", "issues": issues, "rebuild": False, "publish": False} + if excluded: + return {"status": "excluded", "issues": issues, "rebuild": False, "publish": False} + + if not source_has_laws: + issues.append("source_missing_laws") + if ( + source_laws_bytes is not None + and source_laws_bytes >= 0 + and source_laws_bytes < TINY_LAWS_BYTES + ): + issues.append("source_laws_tiny") + + if ir_files is None: + issues.append("missing_ir") + else: + names = set(ir_files) + if "manifest.json" not in names: + issues.append("ir_missing_manifest") + for prefix, issue in IR_FAMILY_PREFIXES: + if not any(name.startswith(prefix) for name in names): + issues.append(issue) + if ir_corpus_rows is not None and int(ir_corpus_rows) <= 0: + issues.append("ir_empty_corpus") + if ( + source_revision + and ir_source_revision + and str(source_revision) != str(ir_source_revision) + ): + issues.append("stale_source_revision") + if vector_status in STUB_VECTOR_STATUSES: + issues.append("ir_stub_vectors") + + structural = { + "source_missing_laws", + "source_laws_tiny", + "ir_missing_manifest", + "ir_missing_corpus", + "ir_missing_bm25", + "ir_missing_graph", + "ir_empty_corpus", + } + issue_set = set(issues) + if "missing_ir" in issue_set: + status = "unpublished" if local_only else "missing" + elif "stale_source_revision" in issue_set: + status = "stale" + elif issue_set & structural: + status = "incomplete" + elif issue_set == {"ir_stub_vectors"}: + status = "stub_vectors" + elif not issues: + status = "current" + else: + status = "incomplete" + + local_current = bool( + source_revision + and local_source_revision + and str(source_revision) == str(local_source_revision) + ) + rebuild = ( + status in {"missing", "unpublished", "stale", "incomplete", "stub_vectors"} + and (not local_current or status == "stub_vectors") + ) + publish = status in {"missing", "unpublished", "stale", "incomplete", "stub_vectors"} and ( + "source_missing_laws" not in issues + ) + return { + "status": status, + "issues": issues, + "rebuild": rebuild, + "publish": publish, + } + + +def _ir_source_revision(manifest: Mapping[str, Any] | None) -> str | None: + if not manifest: + return None + pinned = manifest.get("dataset_revision") or (manifest.get("source") or {}).get( + "source_revision" + ) + text = str(pinned or "").strip() + return text or None + + +def _vector_status(manifest: Mapping[str, Any] | None) -> str | None: + if not manifest: + return None + vector = manifest.get("vector") or {} + if isinstance(vector, dict) and vector.get("status"): + return str(vector.get("status")) + incremental = manifest.get("incremental") or {} + nested = incremental.get("vectors") if isinstance(incremental, dict) else None + if isinstance(nested, dict) and nested.get("status"): + return str(nested.get("status")) + if isinstance(vector, dict) and vector.get("stub"): + return "stub" + return None + + +def load_local_manifest(release_dir: Path) -> dict[str, Any]: + path = Path(release_dir) / "manifest.json" + if not path.is_file(): + return {} + try: + data = json.loads(path.read_text(encoding="utf-8")) + except Exception: + return {} + return data if isinstance(data, dict) else {} + + +def _sibling_map(info: Any) -> dict[str, int | None]: + out: dict[str, int | None] = {} + for sib in getattr(info, "siblings", None) or []: + name = str(getattr(sib, "rfilename", "") or "") + if not name: + continue + size = getattr(sib, "size", None) + try: + out[name] = int(size) if size is not None else None # type: ignore[assignment] + except (TypeError, ValueError): + out[name] = None # type: ignore[assignment] + return out + + +def _inspect_source(slug: str, cache_dir: Path | None = None) -> dict[str, Any]: + from huggingface_hub import dataset_info + + from .auth import configure_hf, operator_token, public_token + + repo = f"endomorphosis/ipfs_{slug}_laws" + configure_hf() + info = dataset_info(repo, token=operator_token() or public_token()) + files = _sibling_map(info) + laws_file = next( + (name for name in ("data/laws.parquet", "laws.parquet") if name in files), + None, + ) + arts_file = next( + (name for name in ("data/articles.parquet", "articles.parquet") if name in files), + None, + ) + return { + "repo": repo, + "revision": getattr(info, "sha", None), + "files": sorted(files), + "has_laws": laws_file is not None, + "has_articles": arts_file is not None, + "laws_bytes": files.get(laws_file) if laws_file else None, + "articles_bytes": files.get(arts_file) if arts_file else None, + } + + +def _inspect_ir(slug: str, cache_dir: Path) -> dict[str, Any] | None: + from huggingface_hub import HfApi, dataset_info, hf_hub_download + from huggingface_hub.errors import EntryNotFoundError, RepositoryNotFoundError + + from .auth import configure_hf, operator_token, public_token + + repo = target_repo(slug) + configure_hf() + token = operator_token() or public_token() + try: + info = dataset_info(repo, token=token) + except RepositoryNotFoundError: + return None + files = _sibling_map(info) + if len(files) < 8: + try: + listed = HfApi(token=token).list_repo_files(repo_id=repo, repo_type="dataset") + for name in listed: + files.setdefault(str(name), None) + except Exception: + pass + manifest: dict[str, Any] = {} + if "manifest.json" in files: + try: + path = hf_hub_download( + repo_id=repo, + filename="manifest.json", + repo_type="dataset", + token=token, + cache_dir=str(cache_dir / "hf"), + ) + payload = json.loads(Path(path).read_text(encoding="utf-8")) + if isinstance(payload, dict): + manifest = payload + except (EntryNotFoundError, OSError, json.JSONDecodeError): + manifest = {} + counts = manifest.get("counts") if isinstance(manifest.get("counts"), dict) else {} + return { + "repo": repo, + "hub_revision": getattr(info, "sha", None), + "files": sorted(files), + "manifest": manifest, + "source_revision": _ir_source_revision(manifest), + "corpus_rows": counts.get("corpus_rows"), + "vector_status": _vector_status(manifest), + } + + +def gap_report( + releases_dir: Path | None = None, + *, + slugs: list[str] | None = None, + workers: int = 8, +) -> dict[str, Any]: + """Live Hub scan: missing, stale, incomplete, and unpublished country IR.""" + from .build import CACHE, RELEASES + + sources = slugs or [ + s + for s in list_hub_slugs(author="endomorphosis", kind="source") + if s not in ALIAS_TO_CANONICAL + ] + hub_ir = set(list_hub_slugs(author="justicedao", kind="ir")) + local_dir = Path(releases_dir) if releases_dir else RELEASES + local_ir = set(local_release_slugs(local_dir)) + cache_dir = CACHE + cache_dir.mkdir(parents=True, exist_ok=True) + + rows: list[dict[str, Any]] = [] + + def _one(slug: str) -> dict[str, Any]: + last_exc: Exception | None = None + for attempt in range(4): + try: + source = _inspect_source(slug) + ir = _inspect_ir(slug, cache_dir) if slug in hub_ir else None + break + except Exception as exc: + last_exc = exc + name = type(exc).__name__ + msg = str(exc) + if "429" in msg or "rate limit" in msg.lower(): + time.sleep(min(45, 3 ** attempt * 2)) + continue + raise + else: + raise last_exc or RuntimeError(f"scan failed for {slug}") + local_manifest = load_local_manifest(local_dir / f"ipfs_{slug}_laws_ir") + local_rev = _ir_source_revision(local_manifest) if local_manifest else None + classified = classify_gap( + excluded=slug in EXCLUDED_SLUGS, + alias=False, + source_has_laws=bool(source.get("has_laws")), + source_laws_bytes=source.get("laws_bytes"), + source_revision=source.get("revision"), + ir_files=None if ir is None else ir.get("files"), + ir_source_revision=(ir or {}).get("source_revision") or local_rev, + ir_corpus_rows=(ir or {}).get("corpus_rows") + if ir is not None + else (local_manifest.get("counts") or {}).get("corpus_rows") + if local_manifest + else None, + vector_status=(ir or {}).get("vector_status") + or _vector_status(local_manifest), + local_only=slug in local_ir and slug not in hub_ir, + local_source_revision=local_rev, + ) + return { + "slug": slug, + "source": source.get("repo"), + "target": target_repo(slug), + "source_revision": source.get("revision"), + "ir_source_revision": (ir or {}).get("source_revision"), + "local_source_revision": local_rev, + "has_hub_ir": ir is not None, + "has_local_ir": slug in local_ir, + "source_has_articles": source.get("has_articles"), + "source_laws_bytes": source.get("laws_bytes"), + "corpus_rows": (ir or {}).get("corpus_rows") + if ir is not None + else (local_manifest.get("counts") or {}).get("corpus_rows") + if local_manifest + else None, + "vector_status": (ir or {}).get("vector_status") + or _vector_status(local_manifest), + **classified, + } + + workers = max(1, min(int(workers), 16)) + with ThreadPoolExecutor(max_workers=workers) as pool: + futs = {pool.submit(_one, slug): slug for slug in sources} + for fut in as_completed(futs): + slug = futs[fut] + try: + rows.append(fut.result()) + except Exception as exc: + rows.append( + { + "slug": slug, + "source": f"endomorphosis/ipfs_{slug}_laws", + "target": target_repo(slug), + "status": "incomplete", + "issues": [f"scan_error:{type(exc).__name__}"], + "rebuild": False, + "publish": False, + "error": str(exc), + } + ) + rows.sort(key=lambda r: str(r.get("slug"))) + by_status: dict[str, list[str]] = {} + for row in rows: + by_status.setdefault(str(row.get("status")), []).append(str(row.get("slug"))) + return { + "n": len(rows), + "by_status": {k: sorted(v) for k, v in sorted(by_status.items())}, + "counts": {k: len(v) for k, v in sorted(by_status.items())}, + "rebuild": [r["slug"] for r in rows if r.get("rebuild")], + "publish": [r["slug"] for r in rows if r.get("publish")], + "countries": rows, + } + + +def coverage_report(releases_dir: Path | None = None) -> dict[str, Any]: + from .build import RELEASES + + sources = list_hub_slugs(author="endomorphosis", kind="source") + hub_ir = list_hub_slugs(author="justicedao", kind="ir") + local_ir = local_release_slugs(Path(releases_dir) if releases_dir else RELEASES) + hub_ir_canon = {canonical_slug(s) for s in hub_ir} + local_ir_canon = {canonical_slug(s) for s in local_ir} + missing_hub: list[dict[str, Any]] = [] + missing_local: list[dict[str, Any]] = [] + excluded: list[str] = [] + aliases: list[str] = [] + for slug in sources: + if slug in ALIAS_TO_CANONICAL: + aliases.append(slug) + continue + if slug in EXCLUDED_SLUGS: + excluded.append(slug) + continue + row = { + "slug": slug, + "source": f"endomorphosis/ipfs_{slug}_laws", + "target": target_repo(slug), + } + if slug not in hub_ir_canon: + missing_hub.append(row) + if slug not in local_ir_canon and slug not in hub_ir_canon: + missing_local.append(row) + return { + "n_sources": len(sources), + "n_hub_ir": len(hub_ir), + "n_local_ir": len(local_ir), + "n_catalog": len(all_countries()), + "excluded": excluded, + "alias_sources": aliases, + "missing_justicedao": missing_hub, + "missing_local_and_hub": missing_local, + "local_only": sorted(local_ir_canon - hub_ir_canon), + } diff --git a/country_laws_ir/duckdb_store.py b/country_laws_ir/duckdb_store.py new file mode 100644 index 0000000000000000000000000000000000000000..743473eea8b69f71eb222568bcadf0549160db49 --- /dev/null +++ b/country_laws_ir/duckdb_store.py @@ -0,0 +1,408 @@ +"""DuckDB views over country-laws sparse GraphRAG parquet shards. + +Published artifacts are ZSTD parquet (SkillCenter / publicus-ir family). +Query and large-corpus neighbor generation read those shards through DuckDB +instead of loading them into pandas or SQLite. +""" + +from __future__ import annotations + +import json +from pathlib import Path +from typing import Any + +import pandas as pd + +K1 = 1.2 +B = 0.75 +TITLE_WEIGHT = 5.0 +BODY_WEIGHT = 1.0 +MAX_QUERY_TERMS = 64 + +VIEWS = ( + ("corpus", "data/corpus/*.parquet"), + ("bm25_documents", "data/bm25/documents/*.parquet"), + ("bm25_postings", "data/bm25/postings/*.parquet"), + ("graph_nodes", "data/graph/nodes/*.parquet"), + ("graph_edges", "data/graph/edges/*.parquet"), + # Shared hf_graphrag layout (US Code / state laws / FR). + ("graph_in", "data/graph/adjacency/in/*.parquet"), + ("graph_out", "data/graph/adjacency/out/*.parquet"), + # Legacy country-laws-ir layout still on some Hub packs. + ("graph_incoming", "data/graph/adjacency/incoming/*.parquet"), + ("graph_outgoing", "data/graph/adjacency/outgoing/*.parquet"), + ("vectors", "data/vectors/*.parquet"), +) + + +class DuckDBStoreError(RuntimeError): + """Raised when a parquet/DuckDB sparse index cannot be opened.""" + + +def _require_duckdb(): + try: + import duckdb # type: ignore + except ImportError as exc: + raise DuckDBStoreError("duckdb is required for parquet sparse GraphRAG query") from exc + return duckdb + + +def parquet_glob(root: Path, pattern: str) -> str: + return str(Path(root) / pattern) + + +def connect_release(root: Path, *, database: str = ":memory:"): + """Open a DuckDB connection with views over parquet shards.""" + duckdb = _require_duckdb() + root = Path(root) + if not (root / "manifest.json").is_file(): + raise DuckDBStoreError(f"release missing manifest.json: {root}") + con = duckdb.connect(database) + for name, pattern in VIEWS: + glob = parquet_glob(root, pattern) + if list(root.glob(pattern)): + escaped = glob.replace("'", "''") + con.execute( + f"CREATE OR REPLACE VIEW {name} AS SELECT * FROM read_parquet('{escaped}')" + ) + return con + + +def load_manifest(root: Path) -> dict[str, Any]: + return json.loads((Path(root) / "manifest.json").read_text(encoding="utf-8")) + + +def tokenize(text: str) -> list[str]: + import re + import unicodedata + + if not text: + return [] + nfkd = unicodedata.normalize("NFKD", text) + folded = "".join(ch for ch in nfkd if not unicodedata.combining(ch)).lower() + return re.findall(r"[0-9A-Za-z]+", folded) + + +def bm25_search(root: Path, query: str, top_k: int = 10) -> list[dict[str, Any]]: + """Okapi BM25 over parquet posting shards via DuckDB UNNEST.""" + terms = tokenize(query)[:MAX_QUERY_TERMS] + if not terms: + return [] + manifest = load_manifest(root) + avgdl = float((manifest.get("bm25") or {}).get("average_document_length") or 1.0) or 1.0 + con = connect_release(root) + try: + tables = { + r[0] + for r in con.execute( + "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'" + ).fetchall() + } + if "bm25_postings" not in tables or "bm25_documents" not in tables: + raise DuckDBStoreError("release is missing BM25 parquet shards") + placeholders = ", ".join(["?"] * len(terms)) + sql = f""" + WITH exploded AS ( + SELECT + unnest(document_indices) AS document_index, + unnest(title_frequencies) AS title_tf, + unnest(body_frequencies) AS body_tf, + unnest(document_lengths) AS dl, + idf + FROM bm25_postings + WHERE term IN ({placeholders}) + ), + scored AS ( + SELECT + document_index, + SUM( + idf * ( + ( {TITLE_WEIGHT} * title_tf + {BODY_WEIGHT} * body_tf ) + * ({K1} + 1.0) + ) / ( + ( {TITLE_WEIGHT} * title_tf + {BODY_WEIGHT} * body_tf ) + + {K1} * (1.0 - {B} + {B} * (dl / {avgdl})) + ) + ) AS score + FROM exploded + GROUP BY document_index + ) + SELECT + s.document_index, + s.score, + d.entry_cid, + d.title, + d.record_type + FROM scored s + JOIN bm25_documents d USING (document_index) + ORDER BY s.score DESC, s.document_index + LIMIT ? + """ + rows = con.execute(sql, [*terms, int(top_k)]).fetchall() + cols = [ + "document_index", + "score", + "entry_cid", + "title", + "record_type", + ] + return [dict(zip(cols, row)) for row in rows] + finally: + con.close() + + +def graph_neighbors( + root: Path, + node_cid: str, + *, + direction: str = "both", + limit: int = 25, +) -> list[dict[str, Any]]: + """Adjacency lookup over parquet shards via DuckDB.""" + aliases = { + "both": ("in", "out", "incoming", "outgoing"), + "in": ("in", "incoming"), + "out": ("out", "outgoing"), + "incoming": ("in", "incoming"), + "outgoing": ("out", "outgoing"), + } + dirs = aliases.get(direction, (direction,)) + con = connect_release(root) + try: + tables = { + r[0] + for r in con.execute( + "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'" + ).fetchall() + } + hits: list[dict[str, Any]] = [] + for d in dirs: + view = { + "in": "graph_in", + "out": "graph_out", + "incoming": "graph_incoming", + "outgoing": "graph_outgoing", + }.get(d, d) + if view not in tables: + continue + rows = con.execute( + f""" + SELECT node_cid, neighbor_cids, edge_types, scores + FROM {view} + WHERE node_cid = ? + """, + [node_cid], + ).fetchall() + for node, neighs, types, scores in rows: + neighs = list(neighs or []) + types = list(types or []) + scores = list(scores or []) + for i, neigh in enumerate(neighs): + hits.append( + { + "direction": d, + "node_cid": node, + "neighbor_cid": neigh, + "edge_type": types[i] if i < len(types) else "", + "score": scores[i] if i < len(scores) else None, + } + ) + hits.sort(key=lambda r: (-(r["score"] or 0), str(r["neighbor_cid"]))) + return hits[: int(limit)] + finally: + con.close() + + +def build_fts_index( + corpus_parquet: Path, + duckdb_path: Path, + expected: int, + *, + log: Any | None = None, +) -> Path: + """Load corpus parquet into DuckDB and create an FTS index (no SQLite).""" + duckdb = _require_duckdb() + duckdb_path = Path(duckdb_path) + duckdb_path.parent.mkdir(parents=True, exist_ok=True) + if duckdb_path.exists(): + duckdb_path.unlink() + escaped = str(Path(corpus_parquet).resolve()).replace("'", "''") + con = duckdb.connect(str(duckdb_path)) + try: + con.execute( + f""" + CREATE TABLE documents AS + SELECT + CAST(document_index AS INTEGER) AS document_index, + CAST(entry_cid AS VARCHAR) AS entry_cid, + CAST(COALESCE(title, '') AS VARCHAR) AS title, + CAST(COALESCE(body, '') AS VARCHAR) AS body + FROM read_parquet('{escaped}') + """ + ) + n = int(con.execute("SELECT COUNT(*) FROM documents").fetchone()[0]) + if n != int(expected): + raise DuckDBStoreError(f"DuckDB corpus rows {n} != expected {expected}") + con.execute("INSTALL fts") + con.execute("LOAD fts") + con.execute( + "PRAGMA create_fts_index('documents', 'document_index', 'title', 'body', " + "stemmer='porter', stopwords='english', ignore='(\\.+)', strip_accents=1, lower=1)" + ) + if log: + log(f"duckdb fts ready n={n} path={duckdb_path}") + finally: + con.close() + return duckdb_path + + +def stream_neighbors_to_parquet( + duckdb_path: Path, + spill: Path, + n_docs: int, + *, + k: int = 8, + shard: int = 5000, + batch: int = 256, + resume: bool = True, + log: Any | None = None, +) -> list[Path]: + """Stream DuckDB FTS neighbors into flattened neighbor_*.parquet shards.""" + duckdb = _require_duckdb() + spill = Path(spill) + spill.mkdir(parents=True, exist_ok=True) + existing = sorted(spill.glob("neighbors_*.parquet")) + buf_start = 0 + shard_paths: list[Path] = [] + if resume and existing: + covered = 0 + for path in existing: + parts = path.stem.split("_") + try: + start_i, end_i = int(parts[1]), int(parts[2]) + except (IndexError, ValueError): + continue + if start_i != covered: + break + shard_paths.append(path) + covered = end_i + buf_start = covered + if buf_start >= n_docs: + if log: + log(f"neighbors resume complete {buf_start}/{n_docs}") + return shard_paths + for path in existing: + if path not in shard_paths: + path.unlink(missing_ok=True) + else: + for path in existing: + path.unlink(missing_ok=True) + + con = duckdb.connect(str(duckdb_path), read_only=True) + con.execute("LOAD fts") + rows_buf: list[dict[str, Any]] = [] + shard_start = buf_start + last_idx = buf_start - 1 + done = buf_start + try: + while True: + batch_rows = con.execute( + "SELECT document_index, title, body FROM documents " + "WHERE document_index > ? ORDER BY document_index LIMIT ?", + [last_idx, batch], + ).fetchall() + if not batch_rows: + break + for di, title, body in batch_rows: + di = int(di) + query = (str(title or "").strip() or str(body or "")[:800]).strip() + hits: list[tuple[int, float]] = [] + if query: + hits = con.execute( + "SELECT document_index, " + "fts_main_documents.match_bm25(document_index, ?) AS score " + "FROM documents " + "WHERE document_index != ? AND score IS NOT NULL " + "ORDER BY score DESC, document_index " + "LIMIT ?", + [query, di, int(k)], + ).fetchall() + for neigh_i, score in hits: + rows_buf.append( + { + "source_index": di, + "neighbor_index": int(neigh_i), + "score": float(score or 0.0), + } + ) + last_idx = di + done += 1 + if (di + 1 - shard_start) >= shard: + end = di + 1 + path = spill / f"neighbors_{shard_start:06d}_{end:06d}.parquet" + pd.DataFrame(rows_buf).to_parquet(path, index=False) + shard_paths.append(path) + rows_buf = [] + shard_start = end + if log: + log(f"neighbors parquet shard {path.name}") + if done % 5_000 == 0 and log: + log(f"duckdb neighbors {done}/{n_docs}") + if shard_start < n_docs: + path = spill / f"neighbors_{shard_start:06d}_{n_docs:06d}.parquet" + pd.DataFrame(rows_buf).to_parquet(path, index=False) + shard_paths.append(path) + if log: + log(f"duckdb neighbors done={done} shards={len(shard_paths)}") + return shard_paths + finally: + con.close() + + +def iter_neighbor_parquet_shards(spill: Path) -> Any: + """Yield (start_index, list-of-neighbor-lists) from parquet shards.""" + import pandas as pd + + paths = sorted(Path(spill).glob("neighbors_*.parquet")) + for path in paths: + parts = path.stem.split("_") + start_i = int(parts[1]) + end_i = int(parts[2]) + frame = pd.read_parquet(path) + part: list[list] = [[] for _ in range(max(0, end_i - start_i))] + if not frame.empty: + for rec in frame.itertuples(index=False): + src = int(rec.source_index) + offset = src - start_i + if 0 <= offset < len(part): + part[offset].append( + (int(rec.neighbor_index), float(rec.score), []) + ) + yield start_i, part + + +def materialize_corpus_duckdb(corpus_parquet: Path, duckdb_path: Path) -> Path: + """Load a corpus parquet file into a persistent DuckDB database.""" + duckdb = _require_duckdb() + duckdb_path = Path(duckdb_path) + duckdb_path.parent.mkdir(parents=True, exist_ok=True) + if duckdb_path.exists(): + duckdb_path.unlink() + con = duckdb.connect(str(duckdb_path)) + try: + con.execute( + """ + CREATE TABLE documents AS + SELECT + CAST(document_index AS INTEGER) AS document_index, + CAST(entry_cid AS VARCHAR) AS entry_cid, + CAST(title AS VARCHAR) AS title, + CAST(body AS VARCHAR) AS body + FROM read_parquet(?) + """, + [str(corpus_parquet)], + ) + con.execute("CREATE INDEX documents_idx ON documents(document_index)") + finally: + con.close() + return duckdb_path diff --git a/country_laws_ir/incremental.py b/country_laws_ir/incremental.py new file mode 100644 index 0000000000000000000000000000000000000000..870039d76530cefabb9284ebd6322289345b1c06 --- /dev/null +++ b/country_laws_ir/incremental.py @@ -0,0 +1,518 @@ +"""CID-keyed incremental GraphRAG rebuild for country-laws IR. + +Follows the US Code / patent persistent-index pattern: + +* ``entry_cid`` is the durable identity (not positional ``document_index``). +* A matching source revision + parquet digest is a no-op. +* Unchanged CIDs reuse embeddings; BM25/graph are rebuilt from the current + corpus because ``document_index`` is a shard pointer, not an identity. +* Delta refresh is never labeled equivalent to a full rebuild. + +Public Hub reads stay anonymous. Publication to ``justicedao/*`` is a separate +gated upload step. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from enum import Enum +import json +from pathlib import Path +from typing import Any, Iterable, Mapping + +import pandas as pd + +from . import SCHEMA_VERSION + +class RebuildKind(str, Enum): + UNCHANGED = "unchanged" + DELTA_REFRESH = "delta_refresh" + FULL_REBUILD = "full_rebuild" + + @classmethod + def coerce(cls, value: Any) -> "RebuildKind": + if isinstance(value, RebuildKind): + return value + text = str(value or "").strip().lower().replace("-", "_") + aliases = { + "skip": cls.UNCHANGED, + "noop": cls.UNCHANGED, + "none": cls.UNCHANGED, + "delta": cls.DELTA_REFRESH, + "incremental": cls.DELTA_REFRESH, + "partial": cls.DELTA_REFRESH, + "full": cls.FULL_REBUILD, + "rebuild": cls.FULL_REBUILD, + "force": cls.FULL_REBUILD, + } + if text in aliases: + return aliases[text] + for kind in cls: + if kind.value == text or kind.name.lower() == text: + return kind + raise ValueError(f"unknown rebuild kind: {value!r}") + + +class BuildMode(str, Enum): + AUTO = "auto" + FULL = "full" + DELTA = "delta" + + @classmethod + def coerce(cls, value: Any) -> "BuildMode": + if isinstance(value, BuildMode): + return value + text = str(value or "").strip().lower().replace("-", "_") + aliases = { + "incremental": cls.DELTA, + "diff": cls.DELTA, + "rebuild": cls.FULL, + "complete": cls.FULL, + } + if text in aliases: + return aliases[text] + for mode in cls: + if mode.value == text or mode.name.lower() == text: + return mode + raise ValueError(f"unknown build mode: {value!r}") + + +@dataclass(frozen=True) +class CorpusDelta: + added_cids: tuple[str, ...] = () + removed_cids: tuple[str, ...] = () + unchanged_cids: tuple[str, ...] = () + prior_count: int = 0 + current_count: int = 0 + changed_ratio: float = 1.0 + equivalent_to_full: bool = False + + @property + def n_added(self) -> int: + return len(self.added_cids) + + @property + def n_removed(self) -> int: + return len(self.removed_cids) + + @property + def n_unchanged(self) -> int: + return len(self.unchanged_cids) + + def to_dict(self, *, include_cids: bool = False, cid_sample: int = 8) -> dict[str, Any]: + payload = { + "n_added": self.n_added, + "n_removed": self.n_removed, + "n_unchanged": self.n_unchanged, + "prior_count": self.prior_count, + "current_count": self.current_count, + "changed_ratio": self.changed_ratio, + "equivalent_to_full": self.equivalent_to_full, + } + if include_cids: + payload["added_cids"] = list(self.added_cids) + payload["removed_cids"] = list(self.removed_cids) + payload["unchanged_cids"] = list(self.unchanged_cids) + else: + payload["added_cids_sample"] = list(self.added_cids[:cid_sample]) + payload["removed_cids_sample"] = list(self.removed_cids[:cid_sample]) + return payload + + +@dataclass(frozen=True) +class RebuildPlan: + kind: RebuildKind + mode: BuildMode + reason: str + source_revision: str + prior_revision: str | None = None + source_fingerprint: str = "" + prior_fingerprint: str | None = None + delta: CorpusDelta | None = None + reuse_embeddings: bool = False + skip_build: bool = False + equivalent_to_full: bool = False + + def to_dict(self) -> dict[str, Any]: + return { + "kind": self.kind.value, + "mode": self.mode.value, + "reason": self.reason, + "source_revision": self.source_revision, + "prior_revision": self.prior_revision, + "source_fingerprint": self.source_fingerprint, + "prior_fingerprint": self.prior_fingerprint, + "delta": None if self.delta is None else self.delta.to_dict(include_cids=False), + "reuse_embeddings": self.reuse_embeddings, + "skip_build": self.skip_build, + "equivalent_to_full": self.equivalent_to_full, + "schema_version": SCHEMA_VERSION, + } + + +@dataclass +class PriorRelease: + directory: Path + manifest: dict[str, Any] = field(default_factory=dict) + corpus: pd.DataFrame | None = None + vectors_by_cid: dict[str, list[float]] | None = None + + @property + def source_revision(self) -> str | None: + return ( + self.manifest.get("dataset_revision") + or (self.manifest.get("source") or {}).get("source_revision") + ) + + @property + def fingerprint(self) -> str: + return source_fingerprint_from_manifest(self.manifest) + + +def source_fingerprint(source_meta: Mapping[str, Any]) -> str: + """Stable skip key: Hub SHA plus parquet digests when present.""" + revision = str(source_meta.get("source_revision") or "") + laws = str(source_meta.get("laws_sha256") or "") + articles = str(source_meta.get("articles_sha256") or "") + return f"{revision}|{laws}|{articles}" + + +def source_fingerprint_from_manifest(manifest: Mapping[str, Any]) -> str: + revision = str( + manifest.get("dataset_revision") + or (manifest.get("source") or {}).get("source_revision") + or "" + ) + sha = manifest.get("input_sha256") or {} + laws = str(sha.get("laws.parquet") or "") + articles = str(sha.get("articles.parquet") or "") + if not laws and not articles: + src = manifest.get("source") or {} + laws = str(src.get("laws_sha256") or "") + articles = str(src.get("articles_sha256") or "") + return f"{revision}|{laws}|{articles}" + + +def _cid_set(frame: pd.DataFrame | None) -> set[str]: + if frame is None or frame.empty or "entry_cid" not in frame.columns: + return set() + return {str(x) for x in frame["entry_cid"].dropna().astype(str) if str(x).strip()} + + +def diff_corpus( + prior: pd.DataFrame | None, + current: pd.DataFrame, +) -> CorpusDelta: + """Diff two CID-keyed corpora. Same ``entry_cid`` implies same body.""" + current_cids = _cid_set(current) + prior_cids = _cid_set(prior) + added = tuple(sorted(current_cids - prior_cids)) + removed = tuple(sorted(prior_cids - current_cids)) + unchanged = tuple(sorted(current_cids & prior_cids)) + current_count = int(len(current_cids)) + prior_count = int(len(prior_cids)) + if current_count == 0: + ratio = 1.0 if prior_count else 0.0 + else: + ratio = 1.0 - (len(unchanged) / float(current_count)) + equivalent = prior_count == 0 or (not unchanged and current_count > 0) + return CorpusDelta( + added_cids=added, + removed_cids=removed, + unchanged_cids=unchanged, + prior_count=prior_count, + current_count=current_count, + changed_ratio=float(ratio), + equivalent_to_full=equivalent, + ) + + +def plan_rebuild( + *, + mode: BuildMode | str, + source_meta: Mapping[str, Any], + prior: PriorRelease | None, + current_corpus: pd.DataFrame | None = None, + force: bool = False, + rebuild_stub_vectors: bool = True, +) -> RebuildPlan: + """Decide skip / delta / full from source fingerprints and CID overlap.""" + mode = BuildMode.coerce(mode) + revision = str(source_meta.get("source_revision") or "") + fingerprint = source_fingerprint(source_meta) + prior_revision = prior.source_revision if prior is not None else None + prior_fp = prior.fingerprint if prior is not None else None + + if force or mode is BuildMode.FULL: + delta = None + if current_corpus is not None and prior is not None: + delta = diff_corpus(prior.corpus, current_corpus) + return RebuildPlan( + kind=RebuildKind.FULL_REBUILD, + mode=mode, + reason="operator forced full rebuild" if force else "build mode is full", + source_revision=revision, + prior_revision=prior_revision, + source_fingerprint=fingerprint, + prior_fingerprint=prior_fp, + delta=delta, + reuse_embeddings=False, + skip_build=False, + equivalent_to_full=True, + ) + + if prior is None: + return RebuildPlan( + kind=RebuildKind.FULL_REBUILD, + mode=mode, + reason="no prior release", + source_revision=revision, + prior_revision=None, + source_fingerprint=fingerprint, + prior_fingerprint=None, + delta=None, + reuse_embeddings=False, + skip_build=False, + equivalent_to_full=True, + ) + + prior_vector_status = str( + ((prior.manifest.get("vector") or {}) if prior.manifest else {}).get("status") + or ((prior.manifest.get("incremental") or {}).get("vectors") or {}).get("status") + or "" + ).strip().lower() + stub_vectors = rebuild_stub_vectors and prior_vector_status in { + "stub", + "stub_missing_encoder", + "incomplete", + "partial", + } + + if prior_fp == fingerprint and fingerprint.strip("|") and not stub_vectors: + return RebuildPlan( + kind=RebuildKind.UNCHANGED, + mode=mode, + reason="source revision and parquet digests match prior release", + source_revision=revision, + prior_revision=prior_revision, + source_fingerprint=fingerprint, + prior_fingerprint=prior_fp, + delta=CorpusDelta( + unchanged_cids=tuple(sorted(_cid_set(prior.corpus))), + prior_count=int(len(_cid_set(prior.corpus))), + current_count=int(len(_cid_set(prior.corpus))), + changed_ratio=0.0, + equivalent_to_full=False, + ), + reuse_embeddings=True, + skip_build=True, + equivalent_to_full=False, + ) + + delta = None + if current_corpus is not None: + delta = diff_corpus(prior.corpus, current_corpus) + if delta.equivalent_to_full: + return RebuildPlan( + kind=RebuildKind.FULL_REBUILD, + mode=mode, + reason="CID overlap is empty; delta equals a full rebuild", + source_revision=revision, + prior_revision=prior_revision, + source_fingerprint=fingerprint, + prior_fingerprint=prior_fp, + delta=delta, + reuse_embeddings=False, + skip_build=False, + equivalent_to_full=True, + ) + + reason = ( + "source fingerprint matches but vectors are stub/incomplete; encode missing CIDs" + if stub_vectors and prior_fp == fingerprint + else "source changed; reuse embeddings for unchanged entry_cids" + ) + return RebuildPlan( + kind=RebuildKind.DELTA_REFRESH, + mode=mode, + reason=reason, + source_revision=revision, + prior_revision=prior_revision, + source_fingerprint=fingerprint, + prior_fingerprint=prior_fp, + delta=delta, + reuse_embeddings=True, + skip_build=False, + equivalent_to_full=False, + ) + + +def _read_sharded_parquet(directory: Path) -> pd.DataFrame | None: + if not directory.is_dir(): + return None + parts = sorted(directory.glob("part-*.parquet")) + if not parts: + parts = sorted(p for p in directory.rglob("*.parquet") if p.is_file()) + if not parts: + return None + frames = [pd.read_parquet(p) for p in parts] + return pd.concat(frames, ignore_index=True) if frames else None + + +def load_release_manifest(release_dir: Path) -> dict[str, Any]: + path = Path(release_dir) / "manifest.json" + if not path.is_file(): + return {} + try: + data = json.loads(path.read_text(encoding="utf-8")) + except Exception: + return {} + return data if isinstance(data, dict) else {} + + +def load_release_corpus(release_dir: Path) -> pd.DataFrame | None: + release_dir = Path(release_dir) + corpus = _read_sharded_parquet(release_dir / "data" / "corpus") + if corpus is not None: + return corpus + checkpoint = release_dir / "corpus.parquet" + if checkpoint.is_file(): + return pd.read_parquet(checkpoint) + return None + + +def embeddings_from_vector_table(frame: pd.DataFrame) -> dict[str, list[float]]: + out: dict[str, list[float]] = {} + if frame is None or frame.empty: + return out + if "entry_cid" not in frame.columns or "embedding" not in frame.columns: + return out + for rec in frame.itertuples(index=False): + cid = str(getattr(rec, "entry_cid", "") or "") + emb = getattr(rec, "embedding", None) + if not cid or emb is None: + continue + if isinstance(emb, float) and pd.isna(emb): + continue + try: + values = [float(x) for x in list(emb)] + except Exception: + continue + if not values: + continue + out[cid] = values + return out + + +def load_release_vectors_by_cid(release_dir: Path) -> dict[str, list[float]]: + frame = _read_sharded_parquet(Path(release_dir) / "data" / "vectors") + if frame is None: + return {} + return embeddings_from_vector_table(frame) + + +def load_prior_release(release_dir: Path | None) -> PriorRelease | None: + if release_dir is None: + return None + directory = Path(release_dir) + if not directory.is_dir(): + return None + manifest = load_release_manifest(directory) + if not manifest and not (directory / "data").is_dir(): + return None + return PriorRelease( + directory=directory, + manifest=manifest, + corpus=load_release_corpus(directory), + vectors_by_cid=None, + ) + + +def load_embedding_cache(path: Path) -> dict[str, list[float]]: + if not path.is_file(): + return {} + try: + frame = pd.read_parquet(path) + except Exception: + return {} + return embeddings_from_vector_table(frame) + + +def save_embedding_cache( + path: Path, + by_cid: Mapping[str, Iterable[float]], + *, + model_name: str, + dimension: int, +) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + rows = [ + { + "entry_cid": cid, + "embedding": list(vec), + "model_name": model_name, + "dimension": int(dimension), + } + for cid, vec in sorted(by_cid.items()) + ] + frame = pd.DataFrame(rows) + tmp = path.with_suffix(path.suffix + ".tmp") + frame.to_parquet(tmp, index=False) + tmp.replace(path) + + +def merge_embedding_maps( + *maps: Mapping[str, list[float]] | None, +) -> dict[str, list[float]]: + merged: dict[str, list[float]] = {} + for mapping in maps: + if not mapping: + continue + merged.update(mapping) + return merged + + +def fetch_hub_prior( + slug: str, + dest: Path | None = None, + *, + cache_root: Path | None = None, +) -> Path | None: + """Download JusticeDAO corpus+vector shards to use as an incremental parent. + + Missing Hub IR is not an error: first-time countries return ``None``. + """ + from huggingface_hub import snapshot_download + from huggingface_hub.errors import RepositoryNotFoundError + + from .auth import operator_token, public_token + from .catalog import target_repo + + root = Path(cache_root) if cache_root is not None else ( + Path.home() / ".ipfs_datasets" / "country-laws-ir" / "cache" / "hub-ir" + ) + dest = Path(dest) if dest is not None else (root / slug) + dest.mkdir(parents=True, exist_ok=True) + repo = target_repo(slug) + try: + snapshot_download( + repo_id=repo, + repo_type="dataset", + local_dir=str(dest), + allow_patterns=[ + "manifest.json", + "data/vectors/**", + "data/corpus/**", + "indexes/vector_chunks.parquet", + ], + token=operator_token() or public_token(), + ) + except RepositoryNotFoundError: + return None + except Exception: + if not (dest / "manifest.json").is_file(): + return None + raise + if not (dest / "manifest.json").is_file(): + return None + return dest diff --git a/country_laws_ir/normalize.py b/country_laws_ir/normalize.py index f976040f7a40a86488e840a2770ec00ab62ecac1..b3c348f675dd13ca6f9184c6ffffce5cdfead2d8 100644 --- a/country_laws_ir/normalize.py +++ b/country_laws_ir/normalize.py @@ -1,8 +1,9 @@ """Normalize endomorphosis/ipfs_*_laws into a CID-keyed canonical corpus. Prefer article/section as the retrieval unit; fall back to law-level when -articles are missing or empty. Normalize (NFKC + whitespace collapse) BEFORE -GraphRAG. Never invent legal text or identifiers. +articles are missing or empty. Strip leftover HTML, then detect multilingual +title/chapter/article/section headings (Oregon-style) when present. Never +invent legal text or a hierarchy that is not in the source. Public Hub reads only (token=False). No Hugging Face token is read or stored. """ @@ -11,30 +12,42 @@ from __future__ import annotations import json import os -import re -import unicodedata from collections import Counter from pathlib import Path from typing import Any import pandas as pd from huggingface_hub import dataset_info, hf_hub_download +from huggingface_hub.errors import EntryNotFoundError from . import ENTRY_IDENTITY_SCHEMA, LAW_IDENTITY_SCHEMA, SCHEMA_VERSION from .auth import configure_hf, public_token from .cidutil import cid_of_json, sha256_file, sha256_hex from .schema import SchemaError, validate_articles, validate_laws +from .structure import normalize_legal_text, split_structured_units -_WS_RE = re.compile(r"\s+", re.UNICODE) COLLECTOR_DEFAULT = "endomorphosis/ipfs_datasets_py" +EMPTY_ARTICLE_COLUMNS = ( + "law_id", + "id", + "title", + "text", + "source_url", + "document_number", + "article_number", + "record_type", + "metadata_json", +) + + +def _empty_articles() -> pd.DataFrame: + return pd.DataFrame(columns=list(EMPTY_ARTICLE_COLUMNS)) def normalize_text(value: Any) -> str: if value is None or (isinstance(value, float) and pd.isna(value)): return "" - text = unicodedata.normalize("NFKC", str(value)) - text = _WS_RE.sub(" ", text).strip() - return text + return normalize_legal_text(value) def _s(value: Any) -> str: @@ -53,21 +66,34 @@ def _download(repo_id: str, filename: str, cache_dir: Path) -> Path: return Path(path) -def _resolve_local_parquet(root: Path, name: str) -> Path: +def _repo_filenames(info: Any) -> set[str]: + return {str(getattr(s, "rfilename", "") or "") for s in (getattr(info, "siblings", None) or [])} + + +def _pick_repo_file(filenames: set[str], name: str) -> str | None: + for cand in (f"data/{name}.parquet", f"{name}.parquet"): + if cand in filenames: + return cand + return None + + +def _resolve_local_parquet(root: Path, name: str, *, required: bool = True) -> Path | None: """Accept either /data/.parquet or /.parquet.""" for cand in (root / "data" / f"{name}.parquet", root / f"{name}.parquet"): if cand.is_file(): return cand - raise FileNotFoundError(f"missing {name}.parquet under {root} (tried data/ and root)") + if required: + raise FileNotFoundError(f"missing {name}.parquet under {root} (tried data/ and root)") + return None def load_local_source(local_dir: Path) -> tuple[pd.DataFrame, pd.DataFrame, dict[str, Any]]: """Load a local country-laws pack (filtered preprocess layout).""" local_dir = Path(local_dir).resolve() laws_path = _resolve_local_parquet(local_dir, "laws") - articles_path = _resolve_local_parquet(local_dir, "articles") + articles_path = _resolve_local_parquet(local_dir, "articles", required=False) laws = pd.read_parquet(laws_path) - articles = pd.read_parquet(articles_path) + articles = pd.read_parquet(articles_path) if articles_path is not None else _empty_articles() validate_laws(laws) validate_articles(articles) pack_meta: dict[str, Any] = {} @@ -91,9 +117,9 @@ def load_local_source(local_dir: Path) -> tuple[pd.DataFrame, pd.DataFrame, dict "source_dataset": source_dataset, "source_revision": source_revision, "laws_path": str(laws_path), - "articles_path": str(articles_path), + "articles_path": str(articles_path) if articles_path is not None else None, "laws_sha256": sha256_file(laws_path), - "articles_sha256": sha256_file(articles_path), + "articles_sha256": sha256_file(articles_path) if articles_path is not None else None, "n_laws_source": int(len(laws)), "n_articles_source": int(len(articles)), "laws_columns": list(map(str, laws.columns)), @@ -118,19 +144,27 @@ def load_source(repo_id: str, cache_dir: Path) -> tuple[pd.DataFrame, pd.DataFra os.environ.setdefault("HF_HOME", str(cache_dir / "hf")) info = dataset_info(repo_id, token=public_token()) revision = info.sha - laws_path = _download(repo_id, "data/laws.parquet", cache_dir) - articles_path = _download(repo_id, "data/articles.parquet", cache_dir) + filenames = _repo_filenames(info) + laws_file = _pick_repo_file(filenames, "laws") or "data/laws.parquet" + articles_file = _pick_repo_file(filenames, "articles") + laws_path = _download(repo_id, laws_file, cache_dir) + articles_path: Path | None = None + if articles_file is not None: + try: + articles_path = _download(repo_id, articles_file, cache_dir) + except EntryNotFoundError: + articles_path = None laws = pd.read_parquet(laws_path) - articles = pd.read_parquet(articles_path) + articles = pd.read_parquet(articles_path) if articles_path is not None else _empty_articles() validate_laws(laws) validate_articles(articles) meta = { "source_dataset": repo_id, "source_revision": revision, "laws_path": str(laws_path), - "articles_path": str(articles_path), + "articles_path": str(articles_path) if articles_path is not None else None, "laws_sha256": sha256_file(laws_path), - "articles_sha256": sha256_file(articles_path), + "articles_sha256": sha256_file(articles_path) if articles_path is not None else None, "n_laws_source": int(len(laws)), "n_articles_source": int(len(articles)), "laws_columns": list(map(str, laws.columns)), @@ -248,6 +282,35 @@ def _snapshot_date(row: pd.Series, meta: dict[str, Any], source_meta: dict[str, return "" +def _hierarchy_fields( + title: str, body: str, article_number: str, *, language: str = "" +) -> dict[str, Any]: + """Best-effort hierarchy from a single already-split article/section body.""" + units = split_structured_units( + f"{title}\n{body}" if title else body, language=language + ) + if not units: + return { + "hierarchy_kind": "article" if article_number else "law", + "hierarchy_path": "", + "title_number": "", + "chapter_number": "", + "part_number": "", + "section_number": "", + "subsections": [], + } + unit = units[0] + return { + "hierarchy_kind": unit.kind, + "hierarchy_path": unit.hierarchy_path, + "title_number": unit.title_number, + "chapter_number": unit.chapter_number, + "part_number": unit.part_number, + "section_number": unit.section_number, + "subsections": list(unit.subsections), + } + + def _collector(meta: dict[str, Any], source_dataset: str) -> str: nested = meta.get("metadata") if isinstance(meta.get("metadata"), dict) else {} for blob in (meta, nested): @@ -452,6 +515,9 @@ def build_corpus( "law_status": parent["law_status"], "parent_law_id": instrument_id, "article_id": source_id, + **_hierarchy_fields( + article_title, body, article_number, language=parent["language"] + ), }, ) ) @@ -464,6 +530,49 @@ def build_corpus( report["drop_samples"]["empty_body"].append(instrument_id) continue meta = parent["metadata"] + units = split_structured_units(body, language=parent["language"]) + if units: + report["unit"] = "structured" + for unit in units: + entries.append( + _base_record( + record_type=unit.kind if unit.kind in {"article", "section"} else "article", + source_dataset=source_dataset, + source_revision=source_revision, + instrument_id=instrument_id, + instrument_title=parent["instrument_title"], + law_cid=parent["law_cid"], + article_number=unit.article_number or unit.number, + article_title=unit.heading, + body=unit.body, + jurisdiction=parent["jurisdiction"], + language=parent["language"], + source_url=parent["source_url"], + snapshot_date=_snapshot_date(parent["row"], meta, source_meta), + coverage="structured (headings detected in law body)", + license_expr=parent["license"], + collector=_collector(meta, source_dataset), + source_id=f"{instrument_id}-{unit.kind}-{unit.number}", + extra={ + "eli": parent["eli"], + "identifier": parent["identifier"], + "official_identifier": parent["official_identifier"], + "source_type": parent["source_type"], + "country": parent["country"], + "law_status": parent["law_status"], + "parent_law_id": instrument_id, + "article_id": "", + "hierarchy_kind": unit.kind, + "hierarchy_path": unit.hierarchy_path, + "title_number": unit.title_number, + "chapter_number": unit.chapter_number, + "part_number": unit.part_number, + "section_number": unit.section_number, + "subsections": list(unit.subsections), + }, + ) + ) + continue entries.append( _base_record( record_type="law", @@ -494,6 +603,9 @@ def build_corpus( "law_status": parent["law_status"], "parent_law_id": "", "article_id": "", + **_hierarchy_fields( + parent["instrument_title"], body, "", language=parent["language"] + ), }, ) ) @@ -570,5 +682,23 @@ def build_corpus( "empty_bodies_dropped": report["drops"]["empty_body"], "duplicate_cids_dropped": report["drops"]["duplicate_cid"], } + from .profiles import majority_language, score_heading_languages + + sample_text = "" + if not df.empty and "body" in df.columns: + sample_text = "\n".join(str(x) for x in df["body"].head(40).tolist()) + if "title" in df.columns: + sample_text = "\n".join(str(x) for x in df["title"].head(40).tolist()) + "\n" + sample_text + heading_langs = score_heading_languages(sample_text) + report["heading_language_counts"] = dict(heading_langs) + report["heading_language_majority"] = majority_language(heading_langs) + report["document_language_majority"] = None + if report.get("language_breakdown"): + report["document_language_majority"] = max( + report["language_breakdown"].items(), key=lambda kv: kv[1] + )[0] + from .verify import verify_normalized_corpus + + report["verification"] = verify_normalized_corpus(df, report) df.attrs["normalization_report"] = report return df, report diff --git a/country_laws_ir/package.py b/country_laws_ir/package.py index c905675628f575e5cab5ac71b8ecaf14276e2ed1..05c6be4495ff4b698be8ac375e66f934a3b779b0 100644 --- a/country_laws_ir/package.py +++ b/country_laws_ir/package.py @@ -34,8 +34,11 @@ def package_release( country: dict[str, Any], code_root: Path, normalization_report: dict[str, Any] | None = None, + extra_manifest: dict[str, Any] | None = None, + wipe: bool = True, + skip_bm25_graph: bool = False, ) -> dict[str, Any]: - if out.exists(): + if wipe and out.exists(): shutil.rmtree(out) out.mkdir(parents=True, exist_ok=True) indexes_dir = out / "indexes" @@ -51,78 +54,95 @@ def package_release( ) write_parquet(indexes_dir / "corpus_chunks.parquet", _index_df(corpus_idx)) - bm25_doc_idx = write_sharded( - bm25["documents"], - out / "data" / "bm25" / "documents", - "data/bm25/documents", - kind="bm25_documents", - key_col="entry_cid", - index_col="document_index", - ) - write_parquet(indexes_dir / "bm25_document_chunks.parquet", _index_df(bm25_doc_idx)) - - postings = bm25["postings"] - posting_idx = write_sharded( - postings, - out / "data" / "bm25" / "postings", - "data/bm25/postings", - kind="bm25_postings", - key_col="term", - ) - for row, part_start in zip(posting_idx, range(len(posting_idx))): - shard_df = postings.iloc[part_start * MAX_ROWS_PER_FILE : (part_start + 1) * MAX_ROWS_PER_FILE] - row["term_count"] = int(shard_df["term"].nunique()) if not shard_df.empty else 0 - row["posting_count"] = int(shard_df["document_indices"].map(len).sum()) if not shard_df.empty else 0 - row["token_instance_count"] = row["posting_count"] - write_parquet(indexes_dir / "bm25_keyword_shards.parquet", _index_df(posting_idx)) - - node_idx = write_sharded( - graph["nodes"], - out / "data" / "graph" / "nodes", - "data/graph/nodes", - kind="graph_nodes", - key_col="node_cid", - ) - write_parquet(indexes_dir / "graph_node_chunks.parquet", _index_df(node_idx)) - - edge_idx = write_sharded( - graph["edges"], - out / "data" / "graph" / "edges", - "data/graph/edges", - kind="graph_edges", - key_col="edge_cid", - ) - write_parquet(indexes_dir / "graph_edge_chunks.parquet", _index_df(edge_idx)) - - incoming = graph["incoming"] - outgoing = graph["outgoing"] - in_idx = write_sharded( - incoming if incoming is not None and not incoming.empty else pd.DataFrame( - columns=["node_cid", "page_index", "direction"] - ), - out / "data" / "graph" / "adjacency" / "incoming", - "data/graph/adjacency/incoming", - kind="graph_incoming_adjacency", - key_col="node_cid", - ) - out_idx = write_sharded( - outgoing if outgoing is not None and not outgoing.empty else pd.DataFrame( - columns=["node_cid", "page_index", "direction"] - ), - out / "data" / "graph" / "adjacency" / "outgoing", - "data/graph/adjacency/outgoing", - kind="graph_outgoing_adjacency", - key_col="node_cid", - ) - for rows, direction in ((in_idx, "incoming"), (out_idx, "outgoing")): - for r in rows: - r["direction"] = direction - r["adjacency_count"] = r.get("row_count", 0) - r["node_count"] = r.get("row_count", 0) - r["first_page_index"] = 0 - r["last_page_index"] = 0 - write_parquet(indexes_dir / "graph_incoming_adjacency.parquet", _index_df(in_idx)) - write_parquet(indexes_dir / "graph_outgoing_adjacency.parquet", _index_df(out_idx)) + if skip_bm25_graph: + bm25_doc_idx = [] + posting_idx = [] + postings = pd.DataFrame() + node_idx = [] + edge_idx = [] + in_idx = [] + out_idx = [] + incoming = pd.DataFrame() + outgoing = pd.DataFrame() + bm25 = bm25 or {"documents": pd.DataFrame(), "postings": pd.DataFrame(), "stats": {}} + graph = graph or {"nodes": pd.DataFrame(), "edges": pd.DataFrame(), "stats": {}} + else: + bm25_doc_idx = write_sharded( + bm25["documents"], + out / "data" / "bm25" / "documents", + "data/bm25/documents", + kind="bm25_documents", + key_col="entry_cid", + index_col="document_index", + ) + write_parquet(indexes_dir / "bm25_document_chunks.parquet", _index_df(bm25_doc_idx)) + + postings = bm25["postings"] + posting_idx = write_sharded( + postings, + out / "data" / "bm25" / "postings", + "data/bm25/postings", + kind="bm25_postings", + key_col="term", + ) + for row, part_start in zip(posting_idx, range(len(posting_idx))): + shard_df = postings.iloc[ + part_start * MAX_ROWS_PER_FILE : (part_start + 1) * MAX_ROWS_PER_FILE + ] + row["term_count"] = int(shard_df["term"].nunique()) if not shard_df.empty else 0 + row["posting_count"] = ( + int(shard_df["document_indices"].map(len).sum()) if not shard_df.empty else 0 + ) + row["token_instance_count"] = row["posting_count"] + write_parquet(indexes_dir / "bm25_keyword_shards.parquet", _index_df(posting_idx)) + + node_idx = write_sharded( + graph["nodes"], + out / "data" / "graph" / "nodes", + "data/graph/nodes", + kind="graph_nodes", + key_col="node_cid", + ) + write_parquet(indexes_dir / "graph_node_chunks.parquet", _index_df(node_idx)) + + edge_idx = write_sharded( + graph["edges"], + out / "data" / "graph" / "edges", + "data/graph/edges", + kind="graph_edges", + key_col="edge_cid", + ) + write_parquet(indexes_dir / "graph_edge_chunks.parquet", _index_df(edge_idx)) + + incoming = graph["incoming"] + outgoing = graph["outgoing"] + in_idx = write_sharded( + incoming + if incoming is not None and not incoming.empty + else pd.DataFrame(columns=["node_cid", "page_index", "direction"]), + out / "data" / "graph" / "adjacency" / "incoming", + "data/graph/adjacency/incoming", + kind="graph_incoming_adjacency", + key_col="node_cid", + ) + out_idx = write_sharded( + outgoing + if outgoing is not None and not outgoing.empty + else pd.DataFrame(columns=["node_cid", "page_index", "direction"]), + out / "data" / "graph" / "adjacency" / "outgoing", + "data/graph/adjacency/outgoing", + kind="graph_outgoing_adjacency", + key_col="node_cid", + ) + for rows, direction in ((in_idx, "incoming"), (out_idx, "outgoing")): + for r in rows: + r["direction"] = direction + r["adjacency_count"] = r.get("row_count", 0) + r["node_count"] = r.get("row_count", 0) + r["first_page_index"] = 0 + r["last_page_index"] = 0 + write_parquet(indexes_dir / "graph_incoming_adjacency.parquet", _index_df(in_idx)) + write_parquet(indexes_dir / "graph_outgoing_adjacency.parquet", _index_df(out_idx)) vectors_df = vectors["vectors"] # Drop null embeddings for stub releases so parquet stays typed; keep rows when present. @@ -195,8 +215,8 @@ def package_release( "bm25_documents": int(len(bm25["documents"])), "bm25_keyword_shards": len(posting_idx), "bm25_posting_rows": int(len(postings)), - "bm25_postings": int(bm25["stats"]["n_postings"]), - "bm25_terms": int(bm25["stats"]["n_terms"]), + "bm25_postings": int((bm25.get("stats") or {}).get("n_postings") or 0), + "bm25_terms": int((bm25.get("stats") or {}).get("n_terms") or 0), "corpus_chunks": len(corpus_idx), "corpus_rows": int(len(corpus)), "graph_edge_chunks": len(edge_idx), @@ -214,9 +234,22 @@ def package_release( "n_laws": n_laws, "n_articles": n_articles, } + if skip_bm25_graph and extra_manifest and extra_manifest.get("sparse"): + sparse = extra_manifest["sparse"] + bm25_counts = (sparse.get("bm25") or {}).get("counts") or {} + graph_counts = sparse.get("graph") or {} + counts.update( + {k: int(v) for k, v in bm25_counts.items() if isinstance(v, (int, float))} + ) + if graph_counts.get("node_count") is not None: + counts["graph_nodes"] = int(graph_counts["node_count"]) + if graph_counts.get("edge_count") is not None: + counts["graph_edges"] = int(graph_counts["edge_count"]) def idx_desc(name: str) -> dict[str, Any]: path = indexes_dir / name + if not path.is_file(): + return {"relative_path": f"indexes/{name}", "present": False} return file_descriptor(path, f"indexes/{name}") hub_id = target_repo(country["slug"]) @@ -247,6 +280,7 @@ def package_release( "compression_level": 6, "max_rows_per_file": MAX_ROWS_PER_FILE, "row_group_size": MAX_ROWS_PER_FILE, + "query_engine": "duckdb", }, "graph": { "adjacency_pointers_per_row": ADJ_POINTERS_PER_ROW, @@ -324,12 +358,35 @@ def package_release( }, "source": source_meta, } + if extra_manifest: + manifest.update(extra_manifest) (out / "manifest.json").write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") _write_readme(out, country, source_meta, counts, bm25["stats"], graph["stats"], vectors["stats"], hub_id) _write_gitattributes(out) + _write_dataset_configs(out) return manifest +def _write_dataset_configs(out: Path) -> None: + configs = { + "country-laws-ir-graphrag/v1": { + "data_files": { + "corpus": "data/corpus/*.parquet", + "bm25_documents": "data/bm25/documents/*.parquet", + "bm25_postings": "data/bm25/postings/*.parquet", + "graph_nodes": "data/graph/nodes/*.parquet", + "graph_edges": "data/graph/edges/*.parquet", + "graph_adjacency_out": "data/graph/adjacency/out/*.parquet", + "graph_adjacency_in": "data/graph/adjacency/in/*.parquet", + "vectors": "data/vectors/*.parquet", + } + } + } + (out / "dataset_configs.json").write_text( + json.dumps(configs, indent=2) + "\n", encoding="utf-8" + ) + + def _write_gitattributes(out: Path) -> None: (out / ".gitattributes").write_text( "*.parquet filter=lfs diff=lfs merge=lfs -text\n" @@ -546,6 +603,7 @@ def package_release_sequential( code_root: Path, normalization_report: dict[str, Any] | None = None, expected_rows: int | None = None, + extra_manifest: dict[str, Any] | None = None, ) -> dict[str, Any]: """Write release layout one section at a time (never hold corpus+bm25+graph+vectors). @@ -753,6 +811,8 @@ def package_release_sequential( def idx_desc(name: str) -> dict[str, Any]: path = indexes_dir / name + if not path.is_file(): + return {"relative_path": f"indexes/{name}", "present": False} return file_descriptor(path, f"indexes/{name}") manifest = { @@ -835,11 +895,14 @@ def package_release_sequential( }, "source": source_meta, } + if extra_manifest: + manifest.update(extra_manifest) (out / "manifest.json").write_text( json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8" ) _write_readme(out, country, source_meta, counts, bm25_stats, gstats, vstats, hub_id) _write_gitattributes(out) + _write_dataset_configs(out) checkpoint("package_seq_done") return manifest @@ -853,14 +916,20 @@ def package_from_spill( code_root: Path, normalization_report: dict[str, Any] | None = None, expected_rows: int | None = None, + extra_manifest: dict[str, Any] | None = None, ) -> dict[str, Any]: - """Package from spill dir artifacts: bm25_*.parquet, bm25_stats.pkl, graph.pkl, vectors.pkl.""" + """Package from spill dir artifacts: bm25_*.parquet, bm25_stats.json, graph.pkl, vectors.pkl.""" + import json as _json import pickle as _pickle spill = Path(spill) - stats_path = spill / "bm25_stats.pkl" - with stats_path.open("rb") as f: - bm25_stats = _pickle.load(f) + stats_json = spill / "bm25_stats.json" + stats_pkl = spill / "bm25_stats.pkl" + if stats_json.is_file(): + bm25_stats = _json.loads(stats_json.read_text(encoding="utf-8")) + else: + with stats_pkl.open("rb") as f: + bm25_stats = _pickle.load(f) return package_release_sequential( out, corpus_path=Path(corpus_path), @@ -874,4 +943,5 @@ def package_from_spill( code_root=Path(code_root), normalization_report=normalization_report, expected_rows=expected_rows, + extra_manifest=extra_manifest, ) diff --git a/country_laws_ir/profiles.py b/country_laws_ir/profiles.py new file mode 100644 index 0000000000000000000000000000000000000000..44c3d6a91b3c1bf18ede24a585e0409d7ca37518 --- /dev/null +++ b/country_laws_ir/profiles.py @@ -0,0 +1,124 @@ +"""Per-language legal heading lexicons for country-law structure extraction. + +Oregon (ORS) is English title/chapter/section. Other gazettes use their own +words (Artikel, Titre, Artículo, 条, مادة). This table is how we *score* +whether a split used the right language — not a claim that every country +has a dedicated parser. + +Languages with no lexicon (ar, zh, ja, ko, …) must not be force-split on +Latin TITLE/ARTICLE markers; collectors may already have article rows. +""" + +from __future__ import annotations + +from collections import Counter +import re +from typing import Any + +# keyword -> list of (kind, language); some words are shared (article). +HEADING_LEXICON: dict[str, list[tuple[str, str]]] = {} + +def _add(lang: str, kind: str, *words: str) -> None: + for word in words: + HEADING_LEXICON.setdefault(word.casefold(), []).append((kind, lang)) + + +_add("en", "title", "title") +_add("en", "chapter", "chapter") +_add("en", "part", "part") +_add("en", "article", "article") +_add("en", "section", "section", "sec.") + +_add("fr", "title", "titre") +_add("fr", "chapter", "chapitre") +_add("fr", "part", "partie") +_add("fr", "article", "article") +_add("fr", "section", "section") + +_add("de", "title", "titel") +_add("de", "chapter", "kapitel") +_add("de", "part", "teil") +_add("de", "article", "artikel") +_add("de", "section", "abschnitt", "paragraf") + +_add("nl", "title", "titel") +_add("nl", "chapter", "hoofdstuk") +_add("nl", "part", "deel") +_add("nl", "article", "artikel") +_add("nl", "section", "paragraaf", "afdeling") + +_add("es", "title", "título", "titulo") +_add("es", "chapter", "capítulo", "capitulo") +_add("es", "part", "parte") +_add("es", "article", "artículo", "articulo") +_add("es", "section", "sección", "seccion") + +_add("pt", "title", "título", "titulo") +_add("pt", "chapter", "capítulo", "capitulo") +_add("pt", "part", "parte") +_add("pt", "article", "artigo") +_add("pt", "section", "secção", "secao") + +_add("it", "title", "titolo") +_add("it", "chapter", "capitolo") +_add("it", "part", "parte") +_add("it", "article", "articolo") +_add("it", "section", "sezione") + +_add("el", "article", "άρθρο", "αρθρο") +_add("hu", "article", "szakasz") +_add("cs", "article", "článek") +_add("sk", "article", "článok") +_add("sl", "article", "član") +_add("nb", "article", "artikkel") +_add("sv", "article", "artikel") +_add("pl", "article", "artykuł", "artykul") +_add("ro", "article", "articolul", "articol") +_add("zh", "article", "条") +_add("ar", "article", "مادة", "المادة") +_add("ja", "article", "条") + +# Shared abbreviation; language left unknown. +_add("und", "article", "art.") +_add("und", "section", "§") + +# Scripts we do not Latin-split: +NO_LATIN_SPLIT_LANGS = frozenset({"ar", "zh", "zh-cn", "zh-tw", "ja", "ko", "fa", "he", "th", "hi", "bn", "am"}) + +_TOKEN_RE = re.compile(r"[^\W\d_]{2,}|art\.|sec\.|§", re.UNICODE) + + +def classify_heading_token(token: str) -> list[tuple[str, str]]: + return list(HEADING_LEXICON.get(token.casefold()) or ()) + + +def score_heading_languages(text: str) -> Counter[str]: + """Count distinctive lexicon hits. Shared words like 'article' do not vote.""" + counts: Counter[str] = Counter() + if not text: + return counts + for token in _TOKEN_RE.findall(text): + hits = classify_heading_token(token) + langs = {lang for _kind, lang in hits if lang != "und"} + if len(langs) == 1: + counts[next(iter(langs))] += 1 + return counts + + +def majority_language(counts: Counter[str], *, exclude: tuple[str, ...] = ("und",)) -> str | None: + filtered = Counter({k: v for k, v in counts.items() if k not in exclude}) + if not filtered: + return None + lang, _n = filtered.most_common(1)[0] + return lang + + +def iso_lang(value: Any) -> str: + text = str(value or "").strip().lower().replace("_", "-") + if not text: + return "" + return text.split("-")[0] + + +def latin_split_allowed(language: str) -> bool: + return iso_lang(language) not in NO_LATIN_SPLIT_LANGS diff --git a/country_laws_ir/query.py b/country_laws_ir/query.py index 04c965ee12f90902c26200bb37af43d46fc8d91d..9cd3a1da6f2ac29b2287609ec1bc797fd55c4774 100644 --- a/country_laws_ir/query.py +++ b/country_laws_ir/query.py @@ -42,6 +42,12 @@ class Release: return pd.read_parquet(path) def bm25(self, query: str, top_k: int = 10) -> list[dict]: + try: + from .duckdb_store import bm25_search + + return bm25_search(self.root, query, top_k=top_k) + except Exception: + pass q_terms = tokenize(query)[:MAX_QUERY_TERMS] if not q_terms: return [] @@ -124,6 +130,12 @@ class Release: return out def neighbors(self, node_cid: str, direction: str = "both", limit: int = 25) -> list[dict]: + try: + from .duckdb_store import graph_neighbors + + return graph_neighbors(self.root, node_cid, direction=direction, limit=limit) + except Exception: + pass dirs = ["incoming", "outgoing"] if direction == "both" else [direction] hits = [] for d in dirs: @@ -164,13 +176,17 @@ def main(argv: list[str] | None = None) -> int: p_vec.add_argument("query") p_vec.add_argument("--top-k", type=int, default=10) p_vec.add_argument("--candidate-centroids", type=int, default=4) - p_vec.add_argument("--device", default="cpu") + p_vec.add_argument("--device", default="cuda") p_g = sub.add_parser("graph") g_sub = p_g.add_subparsers(dest="graph_cmd", required=True) p_n = g_sub.add_parser("neighbors") p_n.add_argument("node_cid") - p_n.add_argument("--direction", default="both", choices=["both", "incoming", "outgoing"]) + p_n.add_argument( + "--direction", + default="both", + choices=["both", "in", "out", "incoming", "outgoing"], + ) p_n.add_argument("--limit", type=int, default=25) args = ap.parse_args(argv) diff --git a/country_laws_ir/raw_package.py b/country_laws_ir/raw_package.py new file mode 100644 index 0000000000000000000000000000000000000000..9a8dba3b577e74e0852042e51cc9d6c21fe0dfbe --- /dev/null +++ b/country_laws_ir/raw_package.py @@ -0,0 +1,324 @@ +"""Incrementally package raw collector instruments into laws/articles parquet. + +Collectors write one JSON instrument per official page under +``$LEGAL_CORPORA_ROOT//instruments/*.json``. Those files grow as new +pages are scraped. This module merges them into the ``endomorphosis/ipfs_*_laws`` +parquet schema without rewriting unchanged rows, so the GraphRAG builder can +delta-rebuild from the resulting pack. + +Never invents legal text or identifiers. Empty/short bodies are dropped, not +filled. +""" + +from __future__ import annotations + +import json +import os +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import pandas as pd + +from .cidutil import sha256_file +from .schema import LAW_FIELD_MAP, REQUIRED_ARTICLE_COLUMNS, REQUIRED_LAW_COLUMNS + +LAW_COLS = [ + "id", + "title", + "text", + "source_url", + "source_type", + "jurisdiction", + "country", + "language", + "eli", + "date", + "date_issued", + "retrieved_at", + "license", + "law_status", + "identifier", + "official_identifier", + "article_count", + "json_path", + "metadata_json", +] +ART_COLS = [ + "law_id", + "id", + "title", + "text", + "source_url", + "document_number", + "article_number", + "record_type", + "metadata_json", +] + +MIN_BODY_CHARS = 80 +DEFAULT_CORPORA_ROOT = Path( + os.environ.get( + "LEGAL_CORPORA_ROOT", + str(Path.home() / ".ipfs_datasets" / "legal-corpora"), + ) +) + + +def _s(value: Any) -> str: + if value is None: + return "" + return str(value).strip() + + +def _meta_json(value: Any) -> str: + if isinstance(value, str): + return value + try: + return json.dumps(value or {}, ensure_ascii=False) + except Exception: + return "{}" + + +def instruments_to_frames( + instruments_dir: Path, + *, + min_body_chars: int = MIN_BODY_CHARS, +) -> tuple[pd.DataFrame, pd.DataFrame, dict[str, Any]]: + """Read collector JSON instruments into laws/articles dataframes.""" + laws: list[dict[str, Any]] = [] + arts: list[dict[str, Any]] = [] + skipped_short = 0 + skipped_bad = 0 + root = Path(instruments_dir) + files = sorted(root.glob("*.json")) if root.is_dir() else [] + for path in files: + try: + rec = json.loads(path.read_text(encoding="utf-8")) + except Exception: + skipped_bad += 1 + continue + if not isinstance(rec, dict): + skipped_bad += 1 + continue + text = _s(rec.get("text")) + ident = _s(rec.get("id")) + title = _s(rec.get("title")) + if not ident or not title or len(text) < min_body_chars: + skipped_short += 1 + continue + meta = rec.get("metadata") or {} + laws.append( + { + "id": ident, + "title": title, + "text": text, + "source_url": _s(rec.get("source_url")), + "source_type": _s(rec.get("source_type")), + "jurisdiction": _s(rec.get("jurisdiction")), + "country": _s(rec.get("country")), + "language": _s(rec.get("language")), + "eli": _s(rec.get("eli")) or None, + "date": _s(rec.get("date")) or None, + "date_issued": _s(rec.get("date_issued") or rec.get("date")) or None, + "retrieved_at": _s(rec.get("retrieved_at")) or None, + "license": _s(rec.get("license")), + "law_status": _s(rec.get("law_status")), + "identifier": _s(rec.get("identifier")) or ident, + "official_identifier": _s(rec.get("official_identifier")), + "article_count": rec.get("article_count") or len(rec.get("documents") or []), + "json_path": f"instruments/{path.name}", + "metadata_json": _meta_json(meta), + } + ) + for doc in rec.get("documents") or []: + if not isinstance(doc, dict): + continue + art_id = _s(doc.get("id")) + art_title = _s(doc.get("title")) + art_text = _s(doc.get("text")) + if not art_id or not art_title or not art_text: + continue + arts.append( + { + "law_id": ident, + "id": art_id, + "title": art_title, + "text": art_text, + "source_url": _s(doc.get("source_url")) or _s(rec.get("source_url")), + "document_number": _s(doc.get("document_number")), + "article_number": _s(doc.get("article_number")), + "record_type": _s(doc.get("record_type")) or "article", + "metadata_json": _meta_json(doc.get("metadata") or {}), + } + ) + report = { + "n_instrument_files": len(files), + "n_laws": len(laws), + "n_articles": len(arts), + "skipped_short_or_empty": skipped_short, + "skipped_unreadable": skipped_bad, + "min_body_chars": min_body_chars, + "never_invented_legal_text": True, + "required_law_columns": list(REQUIRED_LAW_COLUMNS), + "required_article_columns": list(REQUIRED_ARTICLE_COLUMNS), + "law_field_map": dict(LAW_FIELD_MAP), + } + return ( + pd.DataFrame(laws, columns=LAW_COLS), + pd.DataFrame(arts, columns=ART_COLS), + report, + ) + + +def _retrieved_key(value: Any) -> str: + return _s(value) + + +def merge_laws(prior: pd.DataFrame | None, incoming: pd.DataFrame) -> pd.DataFrame: + """Upsert laws by ``id``. Newer ``retrieved_at`` wins; otherwise incoming wins.""" + if prior is None or prior.empty: + return incoming.copy() if incoming is not None else pd.DataFrame(columns=LAW_COLS) + if incoming is None or incoming.empty: + return prior.copy() + by_id: dict[str, dict[str, Any]] = {} + for frame, incoming_flag in ((prior, False), (incoming, True)): + for rec in frame.to_dict(orient="records"): + ident = _s(rec.get("id")) + if not ident: + continue + existing = by_id.get(ident) + if existing is None: + by_id[ident] = rec + continue + if incoming_flag: + new_ts = _retrieved_key(rec.get("retrieved_at")) + old_ts = _retrieved_key(existing.get("retrieved_at")) + if not old_ts or new_ts >= old_ts: + by_id[ident] = rec + rows = [by_id[k] for k in sorted(by_id)] + return pd.DataFrame(rows, columns=LAW_COLS) + + +def merge_articles(prior: pd.DataFrame | None, incoming: pd.DataFrame) -> pd.DataFrame: + """Upsert articles by ``id``. Incoming replaces the same article id.""" + if prior is None or prior.empty: + return incoming.copy() if incoming is not None else pd.DataFrame(columns=ART_COLS) + if incoming is None or incoming.empty: + return prior.copy() + by_id: dict[str, dict[str, Any]] = {} + for frame in (prior, incoming): + for rec in frame.to_dict(orient="records"): + ident = _s(rec.get("id")) + if not ident: + continue + by_id[ident] = rec + rows = [by_id[k] for k in sorted(by_id)] + return pd.DataFrame(rows, columns=ART_COLS) + + +def load_existing_parquet(pack_dir: Path) -> tuple[pd.DataFrame | None, pd.DataFrame | None]: + pack_dir = Path(pack_dir) + laws_path = None + arts_path = None + for cand in (pack_dir / "data" / "laws.parquet", pack_dir / "laws.parquet"): + if cand.is_file(): + laws_path = cand + break + for cand in (pack_dir / "data" / "articles.parquet", pack_dir / "articles.parquet"): + if cand.is_file(): + arts_path = cand + break + laws = pd.read_parquet(laws_path) if laws_path else None + arts = pd.read_parquet(arts_path) if arts_path else None + return laws, arts + + +def write_pack( + out: Path, + laws: pd.DataFrame, + articles: pd.DataFrame, + *, + slug: str, + source_dataset: str, + name: str | None = None, + extra_meta: dict[str, Any] | None = None, +) -> dict[str, Any]: + """Write a local pack that ``load_source`` / ``get_country`` can consume.""" + out = Path(out) + data_dir = out / "data" + data_dir.mkdir(parents=True, exist_ok=True) + laws_path = data_dir / "laws.parquet" + arts_path = data_dir / "articles.parquet" + laws.to_parquet(laws_path, index=False) + articles.to_parquet(arts_path, index=False) + now = datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z") + meta = { + "slug": slug, + "repo": source_dataset, + "source_dataset": source_dataset, + "name": name or slug.replace("_", " ").title(), + "indexable": True, + "source_revision": f"local:{now}", + "n_laws": int(len(laws)), + "n_articles": int(len(articles)), + "laws_sha256": sha256_file(laws_path), + "articles_sha256": sha256_file(arts_path), + "generated_at": now, + "incremental": True, + } + if extra_meta: + meta.update(extra_meta) + (out / "pack_meta.json").write_text( + json.dumps(meta, indent=2, ensure_ascii=False) + "\n", + encoding="utf-8", + ) + return meta + + +def package_instruments( + *, + instruments_dir: Path, + out: Path, + slug: str, + source_dataset: str | None = None, + prior_pack: Path | None = None, + name: str | None = None, + min_body_chars: int = MIN_BODY_CHARS, +) -> dict[str, Any]: + """Merge collector JSON (+ optional prior parquet) into a local IR source pack.""" + incoming_laws, incoming_arts, extract_report = instruments_to_frames( + instruments_dir, min_body_chars=min_body_chars + ) + prior_laws = prior_arts = None + prior_dir = Path(prior_pack) if prior_pack else (out if out.exists() else None) + if prior_dir is not None: + prior_laws, prior_arts = load_existing_parquet(prior_dir) + laws = merge_laws(prior_laws, incoming_laws) + articles = merge_articles(prior_arts, incoming_arts) + if laws.empty: + raise RuntimeError( + f"no laws with text>={min_body_chars} under {instruments_dir}" + ) + repo = source_dataset or f"endomorphosis/ipfs_{slug}_laws" + meta = write_pack( + out, + laws, + articles, + slug=slug, + source_dataset=repo, + name=name, + extra_meta={"extract": extract_report}, + ) + meta["extract"] = extract_report + meta["n_laws_prior"] = int(len(prior_laws)) if prior_laws is not None else 0 + meta["n_articles_prior"] = int(len(prior_arts)) if prior_arts is not None else 0 + meta["n_laws_incoming"] = int(len(incoming_laws)) + meta["n_articles_incoming"] = int(len(incoming_arts)) + meta["out"] = str(out) + return meta + + +def default_instruments_dir(iso_or_slug: str, root: Path | None = None) -> Path: + base = Path(root) if root is not None else DEFAULT_CORPORA_ROOT + return base / iso_or_slug / "instruments" diff --git a/country_laws_ir/sparse.py b/country_laws_ir/sparse.py new file mode 100644 index 0000000000000000000000000000000000000000..5ed793543ef74b1c48e313ee29cada56fd2aface --- /dev/null +++ b/country_laws_ir/sparse.py @@ -0,0 +1,137 @@ +"""Country-law sparse GraphRAG export through the shared HF GraphRAG builders. + +This is the same parquet layout used by US Code, state laws, Federal Register, +and SkillCenter: + +* ``ipfs_datasets_py.retrieval.hf_graphrag.bm25.build_bm25_layout`` +* ``ipfs_datasets_py.retrieval.hf_graphrag.graph.write_graph_layout`` + +No SQLite. Indexes are ZSTD parquet shards under ``data/bm25`` and +``data/graph``. DuckDB queries those shards at read time. +""" + +from __future__ import annotations + +from pathlib import Path +from typing import Any + +import pandas as pd + +from . import EDGE_IDENTITY_SCHEMA, SCHEMA_VERSION +from .cidutil import cid_of_json +from .graph import build_graph + + +def corpus_to_bm25_rows(corpus: pd.DataFrame) -> list[dict[str, Any]]: + """Project a normalized country-law corpus onto the shared BM25 row schema. + + Rows with no searchable tokens are omitted. The shared + ``build_bm25_layout`` builder fail-closes on empty documents (same + admission rule as US Code / Federal Register). + """ + from ipfs_datasets_py.retrieval.hf_graphrag.bm25 import tokenize_bm25_text + + _MAX_TITLE = 8_192 + _MAX_BODY = 200_000 + rows: list[dict[str, Any]] = [] + for rec in corpus.itertuples(index=False): + title = str(getattr(rec, "title", "") or "").replace("\x00", "").strip() + body = str(getattr(rec, "body", "") or "").replace("\x00", "").strip() + if len(title) > _MAX_TITLE: + title = title[:_MAX_TITLE].rstrip() + if len(body) > _MAX_BODY: + body = body[:_MAX_BODY].rstrip() + if not title and not body: + continue + if not tokenize_bm25_text(title) and not tokenize_bm25_text(body): + continue + rows.append( + { + "entry_cid": str(rec.entry_cid), + "title": title, + "body": body, + "record_type": str(getattr(rec, "record_type", "") or "law"), + "document_index": int(rec.document_index), + } + ) + if not rows: + raise RuntimeError("no corpus rows had searchable BM25 tokens") + for i, row in enumerate(rows): + row["document_index"] = i + return rows + + +def _graph_nodes_and_edges(corpus: pd.DataFrame) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + """Structural graph only (no precomputed BM25 neighbor matrix).""" + built = build_graph(corpus, [[] for _ in range(len(corpus))]) + nodes = [ + { + "node_cid": str(row["node_cid"]), + "node_type": str(row["node_type"]), + "label": row.get("label"), + "entry_cid": row.get("entry_cid") or None, + } + for row in built["nodes"].to_dict("records") + ] + edges = [] + for row in built["edges"].to_dict("records"): + source = str(row.get("source_cid") or row.get("source_node_cid") or "") + target = str(row.get("target_cid") or row.get("target_node_cid") or "") + edge_type = str(row.get("edge_type") or "") + if not source or not target or not edge_type: + continue + edge_cid = str(row.get("edge_cid") or "") or cid_of_json( + { + "edge_type": edge_type, + "schema": EDGE_IDENTITY_SCHEMA, + "source": source, + "target": target, + } + ) + edges.append( + { + "edge_cid": edge_cid, + "edge_type": edge_type, + "source_node_cid": source, + "target_node_cid": target, + "retrieval_method": str(row.get("retrieval_method") or "structural"), + "score": row.get("score"), + } + ) + return nodes, edges + + +def export_sparse_graphrag( + corpus: pd.DataFrame, + output_dir: Path, +) -> dict[str, Any]: + """Write BM25 + graph parquet shards using the shared HF GraphRAG builders.""" + from ipfs_datasets_py.retrieval.hf_graphrag.bm25 import ( + BM25LayoutConfig, + build_bm25_layout, + ) + from ipfs_datasets_py.retrieval.hf_graphrag.graph import write_graph_layout + + output_dir = Path(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + rows = corpus_to_bm25_rows(corpus) + bm25 = build_bm25_layout( + rows, + output_dir, + config=BM25LayoutConfig(max_documents=max(len(rows), 1)), + ) + nodes, edges = _graph_nodes_and_edges(corpus) + written = write_graph_layout(nodes, edges, output_dir) + layout = written.layout + return { + "engine": "hf_graphrag", + "schema_version": SCHEMA_VERSION, + "bm25": bm25.to_manifest_fragment(), + "graph": { + "node_count": int(layout.node_count), + "edge_count": int(layout.edge_count), + "adjacency": "data/graph/adjacency/{out,in}/*.parquet", + }, + "sqlite": False, + "query_engine": "duckdb", + } diff --git a/country_laws_ir/spill.py b/country_laws_ir/spill.py index 4165b480d20436301555ab206b43f07cbe4cfd08..208b549fe475cc6f34575aa2518289a6c6cdd275 100644 --- a/country_laws_ir/spill.py +++ b/country_laws_ir/spill.py @@ -1,17 +1,15 @@ -"""Disk-spill helpers for large country IR builds (SQLite FTS neighbors + BM25 TF). +"""Disk-spill helpers for large country IR builds (DuckDB + parquet). Design (CoS / DO OOM lesson): - Embeddings: checkpointed .npy via vectors.encode_corpus (unchanged). -- Neighbors for n >= SQLITE_THRESHOLD (40k): SQLite FTS5 title-only MATCH streaming - into neighbor_*.pkl shards under cache/_bm25_spill/ — never hold full - neighbor matrix in RAM during streaming. -- BM25 TF: stream tokenize → SQLite WITHOUT ROWID → posting parquet parts. -- Package: use package.package_release_sequential / package_from_spill so corpus, - bm25, graph, vectors are never all resident together; neighbor edges can be - streamed from shards into graph then spilled as graph.pkl. - -Resume-safe: existing FTS DB / neighbor shards / bm25_*.parquet are reused when -row counts match. +- Neighbors for n >= DUCKDB_THRESHOLD (40k): DuckDB FTS over corpus parquet, + streamed into neighbor_*.parquet shards — never hold the full neighbor + matrix in RAM. +- BM25 TF: stream tokenize → DuckDB → posting parquet parts. +- Package: sequential parquet write so corpus, bm25, graph, vectors are never + all resident together. + +No SQLite. Intermediate and published artifacts are parquet / DuckDB. """ from __future__ import annotations @@ -19,7 +17,6 @@ import gc import json import math import pickle -import sqlite3 from collections import defaultdict from pathlib import Path from typing import Any, Callable, Iterable, Iterator @@ -41,7 +38,8 @@ from .graph import _adjacency, _edge, build_graph from .mem import MemAbort, checkpoint, log_mem from .tokenize import tokenize -SQLITE_THRESHOLD = 40_000 +DUCKDB_THRESHOLD = 40_000 +SQLITE_THRESHOLD = DUCKDB_THRESHOLD # backward-compatible alias; not SQLite BATCH = 256 NEIGHBOR_SHARD = 5_000 NEIGHBOR_K = 8 @@ -68,19 +66,24 @@ def load_pickle(path: Path) -> Any: return pickle.load(f) -def quote_fts_term(term: str) -> str: - return '"' + term.replace('"', '""') + '"' - - def _idf(n_docs: int, df: int) -> float: return math.log((n_docs - df + 0.5) / (df + 0.5) + 1.0) -def sqlite_ready(db_path: Path, expected: int) -> bool: +def _require_duckdb(): + try: + import duckdb # type: ignore + except ImportError as exc: + raise RuntimeError("duckdb is required for sparse GraphRAG spill (no sqlite)") from exc + return duckdb + + +def duckdb_ready(db_path: Path, expected: int) -> bool: if not db_path.is_file(): return False + duckdb = _require_duckdb() try: - conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True) + conn = duckdb.connect(str(db_path), read_only=True) n = int(conn.execute("SELECT COUNT(*) FROM documents").fetchone()[0]) conn.close() return n == expected @@ -88,265 +91,49 @@ def sqlite_ready(db_path: Path, expected: int) -> bool: return False -def build_sqlite_fts( - corpus_path: Path, - db_path: Path, - expected: int, - *, - batch: int = BATCH, - log: Callable[[str], None] | None = None, -) -> int: - """Contentless FTS5 over title+body; documents table holds query_text.""" - if db_path.exists(): - db_path.unlink() - db_path.parent.mkdir(parents=True, exist_ok=True) - conn = sqlite3.connect(str(db_path)) - try: - conn.executescript( - """ - PRAGMA journal_mode = OFF; - PRAGMA synchronous = OFF; - PRAGMA temp_store = MEMORY; - PRAGMA locking_mode = EXCLUSIVE; - PRAGMA page_size = 32768; - CREATE TABLE documents ( - document_index INTEGER PRIMARY KEY, - entry_cid TEXT NOT NULL UNIQUE, - title TEXT NOT NULL, - query_text TEXT NOT NULL - ); - CREATE VIRTUAL TABLE documents_fts USING fts5( - title, - body, - content='', - columnsize=1, - tokenize='unicode61 remove_diacritics 2' - ); - """ - ) - pf = pq.ParquetFile(corpus_path) - n = 0 - meta_batch: list[tuple] = [] - fts_batch: list[tuple] = [] - conn.execute("BEGIN") - for batch_tbl in pf.iter_batches( - batch_size=batch, columns=["document_index", "entry_cid", "title", "body"] - ): - cols = batch_tbl.to_pydict() - for i in range(len(cols["document_index"])): - di = int(cols["document_index"][i]) - title = str(cols["title"][i] or "") - body = str(cols["body"][i] or "") - cid = str(cols["entry_cid"][i]) - qtext = title.strip() if title.strip() else body[:800] - meta_batch.append((di, cid, title, qtext)) - fts_batch.append((di + 1, title, body)) - if len(meta_batch) >= batch: - conn.executemany( - "INSERT INTO documents(document_index, entry_cid, title, query_text) " - "VALUES (?,?,?,?)", - meta_batch, - ) - conn.executemany( - "INSERT INTO documents_fts(rowid, title, body) VALUES (?,?,?)", - fts_batch, - ) - n += len(meta_batch) - meta_batch.clear() - fts_batch.clear() - if n % 20_000 == 0: - checkpoint(f"fts_insert@{n}", row=n, every_n=20_000, log=log) - gc.collect() - if meta_batch: - conn.executemany( - "INSERT INTO documents(document_index, entry_cid, title, query_text) " - "VALUES (?,?,?,?)", - meta_batch, - ) - conn.executemany( - "INSERT INTO documents_fts(rowid, title, body) VALUES (?,?,?)", - fts_batch, - ) - n += len(meta_batch) - conn.commit() - conn.execute("INSERT INTO documents_fts(documents_fts) VALUES('optimize')") - conn.commit() - conn.execute( - "CREATE VIRTUAL TABLE documents_vocab USING fts5vocab(documents_fts, 'row')" - ) - conn.commit() - got = int(conn.execute("SELECT COUNT(*) FROM documents").fetchone()[0]) - assert got == n == expected, (got, n, expected) - return n - except Exception: - conn.rollback() - raise - finally: - conn.close() - gc.collect() +def build_sqlite_fts(*args, **kwargs): # pragma: no cover - removed + raise RuntimeError("SQLite FTS is removed; use DuckDB parquet neighbors") -def load_df_map(conn: sqlite3.Connection, df_cap: int = DF_CAP) -> dict[str, int]: - df_map: dict[str, int] = {} - for term, doc in conn.execute( - "SELECT term, doc FROM documents_vocab WHERE doc <= ?", (df_cap,) - ): - df_map[str(term)] = int(doc) - return df_map - - -def select_query_terms(query_text: str, df_map: dict[str, int]) -> list[str]: - toks = tokenize(query_text)[:24] - seen: set[str] = set() - cands: list[tuple[int, str]] = [] - for t in toks: - if t in seen or len(t) < 2: - continue - seen.add(t) - if t not in df_map: - continue - cands.append((df_map[t], t)) - cands.sort() - return [t for _, t in cands[:MAX_QTERMS]] - - -def stream_neighbors_to_shards( - db_path: Path, +def neighbors_via_duckdb( + corpus_path: Path, spill: Path, n_docs: int, *, k: int = NEIGHBOR_K, - shard: int = NEIGHBOR_SHARD, - batch: int = BATCH, - df_cap: int = DF_CAP, resume: bool = True, log: Callable[[str], None] | None = None, ) -> list[Path]: - """Stream FTS5 title-only neighbors into neighbor_START_END.pkl shards. + """DuckDB FTS over corpus parquet → neighbor_*.parquet shards. No SQLite.""" + from .duckdb_store import build_fts_index, stream_neighbors_to_parquet - Does not assemble the full neighbor list. Resume skips shards already on disk - whose end index is covered (contiguous from 0). - """ + spill = Path(spill) spill.mkdir(parents=True, exist_ok=True) - existing = sorted(spill.glob("neighbors_*.pkl")) - buf_start = 0 - shard_paths: list[Path] = [] - if resume and existing: - # Contiguous cover from 0 - covered = 0 - for sp in existing: - parts = sp.stem.split("_") - # neighbors_000000_005000 - try: - start_i, end_i = int(parts[1]), int(parts[2]) - except (IndexError, ValueError): - continue - if start_i != covered: - break - shard_paths.append(sp) - covered = end_i - buf_start = covered - if buf_start >= n_docs: - if log: - log(f"neighbors resume complete {buf_start}/{n_docs}") - return shard_paths + db_path = spill / "neighbors.duckdb" + if not duckdb_ready(db_path, n_docs): + if db_path.exists(): + db_path.unlink() if log: - log(f"neighbors resume from {buf_start}/{n_docs} shards={len(shard_paths)}") - # Drop non-contiguous leftover shards beyond covered - for sp in existing: - if sp not in shard_paths: - sp.unlink(missing_ok=True) + log(f"building duckdb fts n={n_docs} -> {db_path}") + build_fts_index(corpus_path, db_path, n_docs, log=log) else: - for sp in existing: - sp.unlink(missing_ok=True) - - conn_rw = sqlite3.connect(str(db_path)) - row = conn_rw.execute( - "SELECT name FROM sqlite_master WHERE name='documents_vocab'" - ).fetchone() - if row is None: - conn_rw.execute( - "CREATE VIRTUAL TABLE documents_vocab USING fts5vocab(documents_fts, 'row')" - ) - conn_rw.commit() - df_map = load_df_map(conn_rw, df_cap) - conn_rw.close() - spill_pickle(spill / "df_map_meta.pkl", {"n_rare": len(df_map), "df_cap": df_cap}) - if log: - log(f"vocab rare_terms={len(df_map)} df_cap={df_cap}") - - conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True) - conn.row_factory = sqlite3.Row - buf: list = [] - done = buf_start - score_sql = f"-bm25(documents_fts, {TITLE_W}, {BODY_W})" - last_idx = buf_start - 1 - try: - while True: - rows = conn.execute( - "SELECT document_index, entry_cid, query_text FROM documents " - "WHERE document_index > ? ORDER BY document_index LIMIT ?", - (last_idx, batch), - ).fetchall() - if not rows: - break - for row in rows: - di = int(row["document_index"]) - terms = select_query_terms(str(row["query_text"]), df_map) - if not terms: - neigh: list = [] - else: - expr = " OR ".join("title : " + quote_fts_term(t) for t in terms) - sql = ( - "SELECT d.document_index, " + score_sql + " AS score " - "FROM documents_fts " - "JOIN documents AS d ON d.document_index = documents_fts.rowid - 1 " - "WHERE documents_fts MATCH ? AND d.document_index != ? " - "ORDER BY score DESC, d.document_index LIMIT ?" - ) - hits = conn.execute(sql, (expr, di, k)).fetchall() - neigh = [ - (int(h["document_index"]), max(0.0, float(h["score"])), list(terms)[:4]) - for h in hits - ] - while buf_start + len(buf) < di: - buf.append([]) - buf.append(neigh) - last_idx = di - done += 1 - if len(buf) >= shard: - end = buf_start + len(buf) - sp = spill / f"neighbors_{buf_start:06d}_{end:06d}.pkl" - spill_pickle(sp, buf) - shard_paths.append(sp) - checkpoint( - f"neighbors_shard_{buf_start}_{end}", - log=log, - ) - buf_start = end - buf = [] - gc.collect() - if done % 5_000 == 0: - checkpoint(f"neighbors_stream", row=done, every_n=5_000, log=log) - if buf: - end = buf_start + len(buf) - sp = spill / f"neighbors_{buf_start:06d}_{end:06d}.pkl" - spill_pickle(sp, buf) - shard_paths.append(sp) - if log: - log(f"neighbors shard final {buf_start}:{end}/{n_docs}") if log: - log(f"bm25 neighbors streamed done={done} n_docs={n_docs} shards={len(shard_paths)}") - return shard_paths - finally: - conn.close() - del df_map - gc.collect() + log(f"reusing duckdb fts n={n_docs} path={db_path}") + return stream_neighbors_to_parquet( + db_path, spill, n_docs, k=k, resume=resume, log=log + ) def iter_neighbor_shards(spill: Path) -> Iterator[tuple[int, list]]: - """Yield (start_index, shard_list) without loading all shards.""" - paths = sorted(spill.glob("neighbors_*.pkl")) + """Yield (start_index, shard_list) from parquet neighbor shards.""" + from .duckdb_store import iter_neighbor_parquet_shards + + parquet = list(Path(spill).glob("neighbors_*.parquet")) + if parquet: + yield from iter_neighbor_parquet_shards(spill) + return + # Legacy pickle shards (pre-DuckDB). Do not create new ones. + paths = sorted(Path(spill).glob("neighbors_*.pkl")) for sp in paths: parts = sp.stem.split("_") start_i = int(parts[1]) @@ -369,30 +156,9 @@ def assemble_neighbors_streaming(spill: Path, n_docs: int) -> list: return neighbors -def neighbors_via_sqlite( - corpus_path: Path, - spill: Path, - n_docs: int, - *, - k: int = NEIGHBOR_K, - resume: bool = True, - log: Callable[[str], None] | None = None, -) -> list[Path]: - """Ensure FTS DB + neighbor shards; return shard paths (not full list).""" - spill.mkdir(parents=True, exist_ok=True) - db_path = spill / "fts.sqlite" - if not sqlite_ready(db_path, n_docs): - if db_path.exists(): - db_path.unlink() - if log: - log(f"building sqlite fts n={n_docs} -> {db_path}") - build_sqlite_fts(corpus_path, db_path, n_docs, log=log) - else: - if log: - log(f"reusing sqlite fts n={n_docs} path={db_path}") - return stream_neighbors_to_shards( - db_path, spill, n_docs, k=k, resume=resume, log=log - ) +def neighbors_via_sqlite(*args, **kwargs): + """Removed. Sparse GraphRAG neighbors are DuckDB/parquet only.""" + return neighbors_via_duckdb(*args, **kwargs) def build_graph_from_neighbor_shards( @@ -492,33 +258,35 @@ def build_bm25_tf_spill( batch: int = 512, log: Callable[[str], None] | None = None, ) -> dict[str, Any]: - """Stream tokenize corpus → SQLite TF → bm25_documents/postings parquet + stats. + """Stream tokenize corpus → DuckDB TF → bm25_documents/postings parquet + stats. - Resume: if bm25_documents.parquet + bm25_postings.parquet + bm25_stats.pkl exist + Resume: if bm25_documents.parquet + bm25_postings.parquet + bm25_stats.json exist with matching n_docs, reuse. """ spill.mkdir(parents=True, exist_ok=True) docs_path = spill / "bm25_documents.parquet" post_path = spill / "bm25_postings.parquet" + stats_json = spill / "bm25_stats.json" stats_path = spill / "bm25_stats.pkl" - if docs_path.is_file() and post_path.is_file() and stats_path.is_file(): - stats = load_pickle(stats_path) - if int(stats.get("n_docs", -1)) == n_docs: + if docs_path.is_file() and post_path.is_file(): + stats = None + if stats_json.is_file(): + stats = json.loads(stats_json.read_text(encoding="utf-8")) + elif stats_path.is_file(): + stats = load_pickle(stats_path) + if stats is not None and int(stats.get("n_docs", -1)) == n_docs: if log: log(f"reusing bm25 spill n_docs={n_docs}") return {"stats": stats, "documents": docs_path, "postings": post_path} - bm25_sql = spill / "bm25_tf.sqlite" - if bm25_sql.exists(): - bm25_sql.unlink() - conn = sqlite3.connect(str(bm25_sql)) - conn.execute("PRAGMA journal_mode=OFF") - conn.execute("PRAGMA synchronous=OFF") - conn.execute("PRAGMA temp_store=MEMORY") - conn.execute("PRAGMA locking_mode=EXCLUSIVE") + duckdb = _require_duckdb() + bm25_db = spill / "bm25_tf.duckdb" + if bm25_db.exists(): + bm25_db.unlink() + conn = duckdb.connect(str(bm25_db)) conn.execute( - "CREATE TABLE tf (term TEXT NOT NULL, doc INTEGER NOT NULL, " - "ttf INTEGER NOT NULL, btf INTEGER NOT NULL, PRIMARY KEY(term, doc)) WITHOUT ROWID" + "CREATE TABLE tf (term VARCHAR NOT NULL, doc INTEGER NOT NULL, " + "ttf INTEGER NOT NULL, btf INTEGER NOT NULL)" ) title_len = np.zeros(n_docs, dtype=np.int32) body_len = np.zeros(n_docs, dtype=np.int32) @@ -549,7 +317,6 @@ def build_bm25_tf_spill( ] processed = 0 batch_rows: list[tuple] = [] - conn.execute("BEGIN") for batch_tbl in pf.iter_batches(batch_size=batch, columns=cols): d = batch_tbl.to_pydict() m = len(d["document_index"]) @@ -593,9 +360,7 @@ def build_bm25_tf_spill( } ) if len(batch_rows) >= 20_000: - conn.executemany( - "INSERT OR REPLACE INTO tf VALUES (?,?,?,?)", batch_rows - ) + conn.executemany("INSERT INTO tf VALUES (?, ?, ?, ?)", batch_rows) batch_rows.clear() processed += m if len(meta_buf) >= 20_000: @@ -612,7 +377,7 @@ def build_bm25_tf_spill( checkpoint(f"bm25_tf_tokenize", row=processed, every_n=20_000, log=log) gc.collect() if batch_rows: - conn.executemany("INSERT OR REPLACE INTO tf VALUES (?,?,?,?)", batch_rows) + conn.executemany("INSERT INTO tf VALUES (?, ?, ?, ?)", batch_rows) batch_rows.clear() if meta_buf: dfm = pd.DataFrame(meta_buf) @@ -623,9 +388,8 @@ def build_bm25_tf_spill( dfm.to_parquet(meta_path, index=False) del dfm meta_buf.clear() - conn.commit() if log: - log("bm25 tf spilled; writing documents") + log("bm25 tf spilled to duckdb; writing documents") doc_len = (title_len * TITLE_WEIGHT + body_len * BODY_WEIGHT).astype(np.float64) avgdl = float(doc_len.mean()) if n_docs else 0.0 @@ -696,7 +460,7 @@ def build_bm25_tf_spill( for term, doc, ttf, btf in conn.execute( "SELECT term, doc, ttf, btf FROM tf ORDER BY term, doc" - ): + ).fetchall(): term = str(term) if cur_term is None: cur_term = term @@ -749,9 +513,9 @@ def build_bm25_tf_spill( "n_posting_rows": int(out_rows), "n_postings": int(n_postings), } - spill_pickle(stats_path, stats) + stats_json.write_text(json.dumps(stats, indent=2) + "\n", encoding="utf-8") try: - bm25_sql.unlink() + bm25_db.unlink() except Exception: pass if log: @@ -759,5 +523,10 @@ def build_bm25_tf_spill( return {"stats": stats, "documents": docs_path, "postings": post_path} -def should_use_sqlite(n_docs: int, threshold: int = SQLITE_THRESHOLD) -> bool: +def should_use_spill(n_docs: int, threshold: int = DUCKDB_THRESHOLD) -> bool: return n_docs >= threshold + + +def should_use_sqlite(n_docs: int, threshold: int = DUCKDB_THRESHOLD) -> bool: + """Alias: large-corpus path is DuckDB/parquet, not SQLite.""" + return should_use_spill(n_docs, threshold) diff --git a/country_laws_ir/structure.py b/country_laws_ir/structure.py new file mode 100644 index 0000000000000000000000000000000000000000..468ecfdfff4eb76dc26a92c33c0e0e82d12c3712 --- /dev/null +++ b/country_laws_ir/structure.py @@ -0,0 +1,305 @@ +"""Extract legal hierarchy from country-law text (Oregon-style, multilingual). + +Oregon Revised Statutes are stored as title / chapter / section / subsection +trees. National gazettes are not that uniform: some use Article/Artikel, +some §, some only a single instrument body. + +This module: + +* strips leftover HTML chrome so GraphRAG sees legal text, not tags; +* detects multilingual heading markers (title/chapter/part/article/section); +* splits an instrument into those units when at least two headings exist; +* otherwise keeps the whole instrument (never invents a hierarchy). + +Subsection markers such as ``(a)`` / ``(1)`` are recorded on the parent +unit; they are not forced into their own retrieval rows. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from html.parser import HTMLParser +import html as html_lib +import re +import unicodedata +from typing import Any + +_WS_RE = re.compile(r"\s+", re.UNICODE) +_HAS_TAG_RE = re.compile(r"]*>") + +# Line-anchored headings. Numbers may be arabic, roman, or dotted (1.2). +_HEADING_RE = re.compile( + r"(?im)^[ \t]*(?:" + r"(?PTITLE|TITRE|TITEL|T[IÍ]TULO|TITOLO|T[IÍ]TUL)\s+" + r"(?P<title_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)" + r"|(?P<chapter>CHAPTER|CHAPITRE|KAPITEL|CAP[IÍ]TULO|CAPITOLO|HOOFDSTUK|CAP\.)\s+" + r"(?P<chapter_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)" + r"|(?P<part>PART|PARTIE|TEIL|PARTE|DEEL)\s+" + r"(?P<part_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)" + r"|(?P<article>ART(?:ICLE|IKEL|ÍCULO|IGO|ICOLO|IKKEL)?\.?|ART\." + r"|ČLÁNEK|ČLÁNOK|ČLAN|SZAKASZ|ΆΡΘΡΟ|ΑΡΘΡΟ)\s+" + r"(?P<article_n>[0-9IVXLCDMΑ-Ω]+[A-Za-zΑ-Ωa-z0-9.\-]*)" + r"|(?P<section>SECTION|SECCI[OÓ]N|SEZIONE|ABSCHNITT|SEC\.)\s+" + r"(?P<section_n>[0-9A-Za-z.\-]+)" + r"|(?P<section_sym>§+)\s*(?P<section_sym_n>[0-9A-Za-z.\-]+)" + r")" + r"(?P<rest>[^\n]{0,200})?" +) + +_SUBSECTION_RE = re.compile(r"\(([0-9A-Za-z]{1,6})\)") + +_KIND_RANK = { + "title": 1, + "chapter": 2, + "part": 3, + "article": 4, + "section": 5, + "subsection": 6, +} + +MIN_SPLIT_HEADINGS = 2 +MIN_UNIT_CHARS = 40 + +_ZH_ART_RE = re.compile( + r"(?:(?<=\n)|^)[ 　]*" + r"(第[一二三四五六七八九十百千万零〇两0-9]+条(?:之[一二三四五六七八九十百0-9]+)?)" +) +_AR_ART_RE = re.compile( + r"(?:(?<=\n)|^)[ \t]*(المادة|مادة)\s*([0-9٠-٩]+)" +) +_JA_ART_RE = re.compile( + r"(?:(?<=\n)|^)[ 　]*(第[0-9一二三四五六七八九十百]+条)" +) + + +class _HTMLText(HTMLParser): + SKIP = {"script", "style", "noscript", "svg", "nav", "footer", "header"} + + def __init__(self) -> None: + super().__init__(convert_charrefs=True) + self.parts: list[str] = [] + self.skip = 0 + + def handle_starttag(self, tag, attrs): + if tag in self.SKIP: + self.skip += 1 + if tag in {"br", "p", "tr", "div", "li", "h1", "h2", "h3"} and self.skip == 0: + self.parts.append("\n") + + def handle_endtag(self, tag): + if tag in self.SKIP and self.skip: + self.skip -= 1 + if tag in {"p", "div", "li", "tr"} and self.skip == 0: + self.parts.append("\n") + + def handle_data(self, data): + if self.skip == 0: + self.parts.append(data) + + +def has_html_tags(text: str) -> bool: + return bool(text and _HAS_TAG_RE.search(text)) + + +def strip_html(raw: str) -> str: + """Turn leftover HTML into visible legal text. No-op if there are no tags.""" + if not raw or not _HAS_TAG_RE.search(raw): + return raw + parser = _HTMLText() + try: + parser.feed(raw) + parser.close() + text = "".join(parser.parts) + except Exception: + text = re.sub(r"(?is)<script.*?>.*?</script>", " ", raw) + text = re.sub(r"(?is)<style.*?>.*?</style>", " ", text) + text = re.sub(r"(?is)<[^>]+>", " ", text) + text = html_lib.unescape(text).replace("\xa0", " ") + text = re.sub(r"[ \t]+", " ", text) + text = re.sub(r"\n[ \t]+", "\n", text) + text = re.sub(r"\n{3,}", "\n\n", text) + return text.strip() + + +def normalize_legal_text(value: Any) -> str: + """NFKC + HTML strip. Keeps newlines so heading detection still works.""" + if value is None: + return "" + text = unicodedata.normalize("NFKC", str(value)) + text = strip_html(text) + text = text.replace("\xa0", " ") + text = re.sub(r"[ \t]+", " ", text) + text = re.sub(r"\n[ \t]+", "\n", text) + text = re.sub(r"\n{3,}", "\n\n", text) + return text.strip() + + +@dataclass +class StructureUnit: + kind: str + number: str + heading: str + body: str + title_number: str = "" + chapter_number: str = "" + part_number: str = "" + article_number: str = "" + section_number: str = "" + subsections: tuple[str, ...] = () + hierarchy_path: str = "" + + def to_dict(self) -> dict[str, Any]: + return { + "kind": self.kind, + "number": self.number, + "heading": self.heading, + "body": self.body, + "title_number": self.title_number, + "chapter_number": self.chapter_number, + "part_number": self.part_number, + "article_number": self.article_number, + "section_number": self.section_number, + "subsections": list(self.subsections), + "hierarchy_path": self.hierarchy_path, + } + + +def _cursor_path(cursor: dict[str, str]) -> str: + parts = [] + for key, label in ( + ("title", "Title"), + ("chapter", "Chapter"), + ("part", "Part"), + ("article", "Article"), + ("section", "Section"), + ): + value = cursor.get(key) or "" + if value: + parts.append(f"{label} {value}") + return " > ".join(parts) + + +def _subsection_tokens(text: str) -> tuple[str, ...]: + seen: list[str] = [] + for match in _SUBSECTION_RE.finditer(text): + token = match.group(1) + if token not in seen: + seen.append(token) + if len(seen) >= 40: + break + return tuple(seen) + + +def _units_from_regex( + text: str, matches: list[re.Match[str]], *, kind: str, lang: str +) -> list[StructureUnit]: + if len(matches) < MIN_SPLIT_HEADINGS: + return [] + units: list[StructureUnit] = [] + for i, match in enumerate(matches): + start = match.start() + end = matches[i + 1].start() if i + 1 < len(matches) else len(text) + chunk = text[start:end].strip() + if len(chunk) < 16: + continue + number = re.sub(r"\s+", "", match.group(0)) + heading = re.sub(r"\s+", " ", chunk.split("\n", 1)[0])[:240] + units.append( + StructureUnit( + kind=kind, + number=number, + heading=heading, + body=chunk, + article_number=number, + hierarchy_path=heading, + ) + ) + return units if len(units) >= MIN_SPLIT_HEADINGS else [] + + +def split_script_units(text: str, language: str) -> list[StructureUnit]: + """Article splits for scripts that must not use Latin TITLE/ARTICLE.""" + from .profiles import iso_lang + + lang = iso_lang(language) + if lang in {"zh", "zh-cn", "zh-tw"}: + prepared = re.sub( + r"(第[一二三四五六七八九十百千万零〇两0-9]+条(?:之[一二三四五六七八九十百0-9]+)?)", + r"\n\1", + text, + ) + return _units_from_regex(prepared, list(_ZH_ART_RE.finditer(prepared)), kind="article", lang="zh") + if lang in {"ar", "fa"}: + prepared = re.sub(r"(المادة|مادة)", r"\n\1", text) + return _units_from_regex(prepared, list(_AR_ART_RE.finditer(prepared)), kind="article", lang="ar") + if lang == "ja": + prepared = re.sub(r"(第[0-9一二三四五六七八九十百]+条)", r"\n\1", text) + return _units_from_regex(prepared, list(_JA_ART_RE.finditer(prepared)), kind="article", lang="ja") + return [] + + +def split_structured_units(text: str, *, language: str = "") -> list[StructureUnit]: + """Split *text* on legal headings. Empty list means keep the whole instrument. + + Latin TITLE/ARTICLE splits are skipped for languages in + ``profiles.NO_LATIN_SPLIT_LANGS`` so Arabic/Chinese bodies are not + carved up on incidental English words. + """ + from .profiles import latin_split_allowed + + if not text or len(text) < 16: + return [] + if language and not latin_split_allowed(language): + return split_script_units(text, language) + matches = list(_HEADING_RE.finditer(text)) + if len(matches) < MIN_SPLIT_HEADINGS: + return [] + cursor = {"title": "", "chapter": "", "part": "", "article": "", "section": ""} + units: list[StructureUnit] = [] + for i, match in enumerate(matches): + start = match.start() + end = matches[i + 1].start() if i + 1 < len(matches) else len(text) + chunk = text[start:end].strip() + kind = "" + number = "" + for name in ("title", "chapter", "part", "article", "section"): + if match.group(name): + kind = name + number = (match.group(f"{name}_n") or "").strip() + break + if match.group("section_sym"): + kind = "section" + number = (match.group("section_sym_n") or "").strip() + if not kind or not number: + continue + cursor[kind] = number + for lower, rank in _KIND_RANK.items(): + if rank > _KIND_RANK[kind]: + cursor[lower] = "" + if len(chunk) < MIN_UNIT_CHARS: + continue + rest = (match.group("rest") or "").strip(" .-:") + heading = re.sub(r"\s+", " ", match.group(0)).strip() + if rest and rest not in heading: + heading = f"{heading} {rest}".strip() + units.append( + StructureUnit( + kind=kind, + number=number, + heading=heading[:240], + body=chunk, + title_number=cursor["title"], + chapter_number=cursor["chapter"], + part_number=cursor["part"], + article_number=cursor["article"], + section_number=cursor["section"], + subsections=_subsection_tokens(chunk), + hierarchy_path=_cursor_path(cursor), + ) + ) + retrieval = [u for u in units if u.kind in {"article", "section"}] + if len(retrieval) >= MIN_SPLIT_HEADINGS: + return retrieval + if len(units) >= MIN_SPLIT_HEADINGS: + return units + return [] diff --git a/country_laws_ir/upload.py b/country_laws_ir/upload.py index 7a40ae7f15d2bad04939d6506de83737f3375336..182e81b8d9d799dce63653f45feaabdfa3c61e84 100644 --- a/country_laws_ir/upload.py +++ b/country_laws_ir/upload.py @@ -1,24 +1,132 @@ -"""Hub upload is intentionally not implemented in this local pipeline. +"""Publish a local country-laws-ir release to the JusticeDAO Hugging Face org. -Later publish (operator machine, never from this run): - - export HF_TOKEN=... # never commit / never echo - hf upload-large-folder justicedao/ipfs_malta_laws_ir \\ - /workspace/country-laws-ir/releases/ipfs_malta_laws_ir \\ - --repo-type dataset --no-private --num-workers 8 \\ - --exclude "**/__pycache__/**" --exclude "**/*.pyc" +Reads stay anonymous (see ``auth.py``). Writes require an explicit ``--upload`` +path, a ``justicedao/`` repo id, and ``HF_TOKEN``. Protected LCR repositories +are fail-closed via ``require_unprotected_or_runtime``. """ from __future__ import annotations +import os from pathlib import Path from typing import Any +from . import TARGET_ORG + +_OPERATOR_HINT = ( + "Publish later with: hf upload-large-folder " + "{repo} {local_dir} --repo-type dataset --no-private --num-workers 8 " + '--exclude "**/__pycache__/**" --exclude "**/*.pyc"' +) + + +class UploadError(RuntimeError): + """Raised when a JusticeDAO upload cannot proceed.""" + + +def _token_from_env() -> str: + for key in ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN"): + value = (os.environ.get(key) or "").strip() + if value: + return value + token_path = Path.home() / ".cache" / "huggingface" / "token" + if token_path.is_file(): + try: + return token_path.read_text(encoding="utf-8").strip() + except OSError: + return "" + return "" + + +def upload_release( + local_dir: Path, + repo_id: str, + *, + token: str | None = None, + commit_message: str | None = None, + create: bool = True, +) -> dict[str, Any]: + local_dir = Path(local_dir) + repo_id = str(repo_id or "").strip() + if not local_dir.is_dir(): + raise UploadError(f"release directory does not exist: {local_dir}") + if not repo_id.startswith(f"{TARGET_ORG}/"): + raise UploadError( + f"country-laws-ir publishes only to {TARGET_ORG}/*; got {repo_id!r}" + ) + if not (local_dir / "manifest.json").is_file(): + raise UploadError(f"release is missing manifest.json: {local_dir}") + + # Fail closed for LCR-protected repos without importing the full package + # (site-packages ipfs_datasets_py can be stale and break this thin packager). + _protected = {"justicedao/ipfs_state_laws", "justicedao/ipfs_federal_register"} + if repo_id in _protected: + raise UploadError( + f"{repo_id} is a protected JusticeDAO repository; " + "mutate it only through legal_corpora_publication_runtime" + ) + try: + from ipfs_datasets_py.huggingface.protected_repo_guard import ( + require_unprotected_or_runtime, + ) + + require_unprotected_or_runtime(repo_id, method="upload_folder") + except UploadError: + raise + except Exception: + pass + + resolved = (token or "").strip() or _token_from_env() + if not resolved: + raise UploadError( + "HF_TOKEN is required for --upload. " + + _OPERATOR_HINT.format(repo=repo_id, local_dir=local_dir) + ) + + from huggingface_hub import HfApi + + api = HfApi(token=resolved) + if create: + api.create_repo(repo_id=repo_id, repo_type="dataset", exist_ok=True, private=False) + ignore = ["**/__pycache__/**", "**/*.pyc", "**/*.tmp", "**/*.tmp.npy"] + n_files = sum(1 for path in local_dir.rglob("*") if path.is_file()) + nbytes = sum(path.stat().st_size for path in local_dir.rglob("*") if path.is_file()) + use_large = n_files >= 80 or nbytes >= 80 * 1024 * 1024 + if use_large and hasattr(api, "upload_large_folder"): + api.upload_large_folder( + folder_path=str(local_dir), + repo_id=repo_id, + repo_type="dataset", + ignore_patterns=ignore, + ) + revision = "" + try: + from huggingface_hub import dataset_info as _dataset_info -def upload_release(local_dir: Path, repo_id: str) -> dict[str, Any]: - raise RuntimeError( - "Hub upload is disabled in the local country-laws-ir pipeline. " - "Publish later with: hf upload-large-folder " - f"{repo_id} {local_dir} --repo-type dataset --no-private --num-workers 8 " - '--exclude "**/__pycache__/**" --exclude "**/*.pyc"' + pinned = _dataset_info(repo_id, token=resolved) + revision = str(getattr(pinned, "sha", "") or "") + except Exception: + revision = "" + return { + "url": f"https://huggingface.co/datasets/{repo_id}", + "repo_id": repo_id, + "revision": revision, + "local_dir": str(local_dir), + "method": "upload_large_folder", + } + info = api.upload_folder( + folder_path=str(local_dir), + repo_id=repo_id, + repo_type="dataset", + commit_message=commit_message + or f"Incremental country-laws-ir GraphRAG release for {repo_id}", + ignore_patterns=ignore, ) + revision = getattr(info, "oid", None) or getattr(info, "commit_id", None) or "" + return { + "url": f"https://huggingface.co/datasets/{repo_id}", + "repo_id": repo_id, + "revision": revision, + "local_dir": str(local_dir), + "method": "upload_folder", + } diff --git a/country_laws_ir/vectors.py b/country_laws_ir/vectors.py index 832330d4cd91244107a3c7080623a23db3eddf55..5651e0f0e052dabffed783715a5b3b4c396a7b5e 100644 --- a/country_laws_ir/vectors.py +++ b/country_laws_ir/vectors.py @@ -14,7 +14,11 @@ import pandas as pd from . import MAX_ROWS_PER_FILE, SCHEMA_VERSION MODEL_NAME = "thenlper/gte-small" +MODEL_REVISION = "17e1f347d17fe144873b1201da91788898c639cd" DIMENSION = 384 +MAX_SEQ_LENGTH = 512 +DEFAULT_DEVICE = "cuda" +SUPPORTED_DEVICES = frozenset({"cpu", "cuda", "cuda:0", "mps", "auto"}) MAX_ROWS_PER_CENTROID = 8192 MAX_SHARDS_PER_CENTROID = 2 @@ -24,41 +28,108 @@ def _l2_normalize(x: np.ndarray, eps: float = 1e-12) -> np.ndarray: return x / np.maximum(n, eps) -def embeddings_available() -> bool: +def device_is_available(device: str) -> bool: + """Probe accelerator availability without loading a model.""" + name = str(device or "").strip().lower() + if not name or name == "cpu": + return True + try: + import torch + except Exception: + return False + if name.startswith("cuda"): + return bool( + getattr(torch, "cuda", None) + and torch.backends.cuda.is_built() + and torch.cuda.is_available() + ) + if name == "mps": + mps = getattr(getattr(torch, "backends", None), "mps", None) + return bool(mps is not None and mps.is_available()) + return False + + +def select_device(requested: str = DEFAULT_DEVICE) -> tuple[str, bool]: + """Prefer CUDA like US Code / Open US Law; fall back to CPU.""" + req = str(requested or DEFAULT_DEVICE).strip().lower() or DEFAULT_DEVICE + if req == "auto": + req = "cuda" + if req not in SUPPORTED_DEVICES and not req.startswith("cuda:"): + raise ValueError(f"unsupported embedding device: {requested!r}") + if device_is_available(req): + return req, False + return "cpu", True + + +def ensure_embedding_stack() -> bool: + """Lazy-import / lazy-install transformers + sentence-transformers. + + Matches ``ipfs_datasets_py.auto_installer.ensure_module`` used by other + GraphRAG producers. Importing this module must not pip-install; first + encode may. + """ + import os + + os.environ.setdefault("TRANSFORMERS_NO_TORCHVISION", "1") try: - import torch # noqa: F401 - from sentence_transformers import SentenceTransformer # noqa: F401 + import sentence_transformers # noqa: F401 + import transformers # noqa: F401 return True + except Exception: + pass + try: + from ipfs_datasets_py.auto_installer import ensure_module, install_for_component + + install_for_component("graphrag") + ensure_module("torchvision", "torchvision") + ensure_module("transformers", "transformers") + module = ensure_module("sentence_transformers", "sentence-transformers") + return module is not None except Exception: return False +def embeddings_available() -> bool: + return ensure_embedding_stack() + + +def _is_real_vector(vec: object) -> bool: + try: + arr = np.asarray(vec, dtype=np.float32).reshape(-1) + except Exception: + return False + if arr.shape[0] != DIMENSION: + return False + if not np.isfinite(arr).all(): + return False + return float(np.linalg.norm(arr)) > 1e-6 + + def encode_corpus( corpus: pd.DataFrame, batch_size: int = 64, - device: str = "cpu", + device: str = DEFAULT_DEVICE, checkpoint_path: str | None = None, chunk_size: int = 4096, ) -> np.ndarray: - """Encode corpus texts with gte-small in chunks; persist checkpoints when given.""" + """Encode corpus texts with pinned gte-small on CUDA when available.""" import json import os from datetime import datetime, timezone from pathlib import Path as _Path + if not ensure_embedding_stack(): + raise RuntimeError( + "sentence-transformers is required for production GTE embeddings; " + "lazy install failed (python -m ipfs_datasets_py.auto_installer)" + ) from sentence_transformers import SentenceTransformer from .auth import configure_hf configure_hf() - cache_root = _Path("/workspace/country-laws-ir/cache/hf") - os.environ.setdefault("HF_HOME", str(cache_root)) - os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1") - os.environ.setdefault( - "SENTENCE_TRANSFORMERS_HOME", - str(cache_root / "sentence-transformers"), - ) + device, _fallback = select_device(device) texts = [] for rec in corpus.itertuples(index=False): title = getattr(rec, "title", None) or getattr(rec, "instrument_title", "") or "" @@ -70,12 +141,22 @@ def encode_corpus( done = 0 ckpt = _Path(checkpoint_path) if checkpoint_path else None meta_path = ckpt.with_suffix(".json") if ckpt else None - meta_n = None + cache_root = _Path( + os.environ.get( + "COUNTRY_LAWS_IR_ROOT", + str(_Path.home() / ".ipfs_datasets" / "country-laws-ir"), + ) + ) / "cache" / "hf" + os.environ.setdefault("HF_HOME", str(cache_root)) + os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1") + os.environ.setdefault("SENTENCE_TRANSFORMERS_HOME", str(cache_root / "sentence-transformers")) if meta_path is not None and meta_path.exists(): try: meta_n = json.loads(meta_path.read_text(encoding="utf-8")).get("n") except Exception: meta_n = None + else: + meta_n = None if ckpt is not None and ckpt.exists(): cached = np.load(ckpt) same_corpus = meta_n is None or int(meta_n) == n @@ -87,56 +168,76 @@ def encode_corpus( ): done = int(cached.shape[0]) out[:done] = cached.astype(np.float32, copy=False) - print(f"embeddings resume {done}/{n} from {ckpt}", flush=True) - else: - print( - f"embeddings checkpoint shape {getattr(cached, 'shape', None)} " - f"meta_n={meta_n} incompatible with {(n, DIMENSION)}; restarting", - flush=True, + if done >= n: + return out + + lock_fh = None + if device.startswith("cuda"): + import fcntl + + lock_path = _Path( + os.environ.get( + "COUNTRY_LAWS_IR_ROOT", + str(_Path.home() / ".ipfs_datasets" / "country-laws-ir"), ) - if done >= n: - return out - model = SentenceTransformer(MODEL_NAME, device=device) - while done < n: - j = min(done + int(chunk_size), n) - chunk = model.encode( - texts[done:j], - batch_size=batch_size, - show_progress_bar=True, - convert_to_numpy=True, - normalize_embeddings=True, + ) / "cuda.encode.lock" + lock_path.parent.mkdir(parents=True, exist_ok=True) + lock_fh = open(lock_path, "a", encoding="utf-8") + fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX) + try: + model = SentenceTransformer( + MODEL_NAME, + revision=MODEL_REVISION, + device=device, ) - out[done:j] = np.asarray(chunk, dtype=np.float32) - done = j - print(f"embeddings checkpoint {done}/{n}", flush=True) try: - from .mem import checkpoint as _mem_checkpoint - _mem_checkpoint(f"embeddings@{done}", row=done, every_n=max(chunk_size, 4096)) - except Exception as _mem_exc: - # MemAbort should propagate; other import issues are non-fatal - from .mem import MemAbort - if isinstance(_mem_exc, MemAbort): - raise - if ckpt is not None: - ckpt.parent.mkdir(parents=True, exist_ok=True) - tmp = ckpt.with_name(ckpt.name + ".tmp.npy") - np.save(tmp, out[:done]) - tmp.replace(ckpt) - if meta_path is not None: - meta_path.write_text( - json.dumps( - { - "n": n, - "done": done, - "dimension": DIMENSION, - "model_name": MODEL_NAME, - "ts": datetime.now(timezone.utc).isoformat(), - } + model.max_seq_length = MAX_SEQ_LENGTH + except Exception: + pass + while done < n: + j = min(done + int(chunk_size), n) + chunk = model.encode( + texts[done:j], + batch_size=batch_size, + show_progress_bar=True, + convert_to_numpy=True, + normalize_embeddings=True, + ) + out[done:j] = np.asarray(chunk, dtype=np.float32) + done = j + if ckpt is not None: + ckpt.parent.mkdir(parents=True, exist_ok=True) + tmp = ckpt.with_name(ckpt.name + ".tmp.npy") + np.save(tmp, out[:done]) + tmp.replace(ckpt) + if meta_path is not None: + meta_path.write_text( + json.dumps( + { + "n": n, + "done": done, + "dimension": DIMENSION, + "model_name": MODEL_NAME, + "ts": datetime.now(timezone.utc).isoformat(), + } + ) + + "\n", + encoding="utf-8", ) - + "\n", - encoding="utf-8", - ) - return out + return out + finally: + if lock_fh is not None: + import fcntl as _fcntl + + _fcntl.flock(lock_fh.fileno(), _fcntl.LOCK_UN) + lock_fh.close() + try: + import torch as _torch + + if _torch.cuda.is_available(): + _torch.cuda.empty_cache() + except Exception: + pass def _spherical_kmeans(x: np.ndarray, k: int, iters: int = 12, seed: int = 0) -> np.ndarray: @@ -160,25 +261,29 @@ def _spherical_kmeans(x: np.ndarray, k: int, iters: int = 12, seed: int = 0) -> def _recursive_clusters(x: np.ndarray, max_size: int = MAX_ROWS_PER_FILE) -> list[np.ndarray]: + """Split vectors into shards of at most *max_size* without unbounded recursion. + + Spherical k-means can fail to split (all points one label). In that case + fall back to an even index split so layout cannot recurse forever. + """ n = len(x) - idx = np.arange(n) - if n <= max_size: - return [idx] - labels = _spherical_kmeans(x, k=2) - clusters = [] - for lab in (0, 1): - members = idx[labels == lab] - if len(members) == 0: + if n == 0: + return [] + pending: list[np.ndarray] = [np.arange(n)] + clusters: list[np.ndarray] = [] + while pending: + idx = pending.pop() + if len(idx) <= max_size: + clusters.append(idx) continue - if len(members) <= max_size: - clusters.append(members) - else: - sub = _recursive_clusters(x[members], max_size=max_size) - clusters.extend([members[s] for s in sub]) - if not clusters: - mid = n // 2 - return [idx[:mid], idx[mid:]] - return clusters + labels = _spherical_kmeans(x[idx], k=2) + parts = [idx[labels == lab] for lab in (0, 1)] + parts = [p for p in parts if len(p)] + if len(parts) < 2 or max(len(p) for p in parts) == len(idx): + mid = len(idx) // 2 + parts = [idx[:mid], idx[mid:]] + pending.extend(parts) + return clusters or [np.arange(n)] def layout_vectors(corpus: pd.DataFrame, embeddings: np.ndarray) -> dict[str, Any]: @@ -333,3 +438,85 @@ def layout_stub_vectors(corpus: pd.DataFrame, reason: str) -> dict[str, Any]: ], }, } + + +def assemble_embeddings( + corpus: pd.DataFrame, + prior_by_cid: dict[str, list[float]] | None = None, + *, + encode_missing: bool = True, + batch_size: int = 64, + device: str = DEFAULT_DEVICE, + checkpoint_path: str | None = None, +) -> tuple[np.ndarray, dict[str, Any]]: + """Align a (n, 384) matrix to *corpus* row order. + + Reuse is CID-keyed and only accepts real GTE vectors (finite, 384-d, + non-zero). Stub/zero priors are treated as missing and re-encoded on + CUDA when available — the US Code / Open US Law contract. + """ + n = int(len(corpus)) + out = np.zeros((n, DIMENSION), dtype=np.float32) + prior = prior_by_cid or {} + reused_idx: list[int] = [] + missing_idx: list[int] = [] + cids = corpus["entry_cid"].astype(str).tolist() if n else [] + for i, cid in enumerate(cids): + vec = prior.get(cid) + if not _is_real_vector(vec): + missing_idx.append(i) + continue + out[i] = np.asarray(vec, dtype=np.float32).reshape(-1) + reused_idx.append(i) + + report: dict[str, Any] = { + "n_docs": n, + "n_reused": len(reused_idx), + "n_encoded": 0, + "n_missing": len(missing_idx), + "model_name": MODEL_NAME, + "model_revision": MODEL_REVISION, + "dimension": DIMENSION, + "status": "reused" if not missing_idx else "partial", + } + resolved, fallback = select_device(device) + report["device"] = resolved + report["device_fallback"] = fallback + if not missing_idx: + report["status"] = "reused" + return _l2_normalize(out) if n else out, report + if not encode_missing: + report["status"] = "incomplete" + return out, report + if not ensure_embedding_stack(): + report["status"] = "stub_missing_encoder" + report["reason"] = "sentence-transformers/transformers lazy install failed" + return out, report + + missing = corpus.iloc[missing_idx].reset_index(drop=True) + encoded = encode_corpus( + missing, + batch_size=batch_size, + device=resolved, + checkpoint_path=checkpoint_path, + ) + for local_i, corpus_i in enumerate(missing_idx): + out[corpus_i] = encoded[local_i] + report["n_encoded"] = int(len(missing_idx)) + report["n_missing"] = 0 + report["status"] = "merged" + return _l2_normalize(out), report + + +def embeddings_by_cid(corpus: pd.DataFrame, matrix: np.ndarray) -> dict[str, list[float]]: + """Project a row-aligned embedding matrix back to a CID map.""" + out: dict[str, list[float]] = {} + if corpus is None or corpus.empty: + return out + x = np.asarray(matrix, dtype=np.float32) + cids = corpus["entry_cid"].astype(str).tolist() + for i, cid in enumerate(cids): + if i >= len(x): + break + out[cid] = x[i].astype(np.float32).tolist() + return out diff --git a/country_laws_ir/verify.py b/country_laws_ir/verify.py new file mode 100644 index 0000000000000000000000000000000000000000..1dc7970bebb9471cbe2372dd16dc7e87a63d786f --- /dev/null +++ b/country_laws_ir/verify.py @@ -0,0 +1,280 @@ +"""Admission verifiers for country-law normalization, before GraphRAG. + +Oregon-style structure is preferred but not required for every gazette. +Verifiers fail closed on invented text, residual HTML, empty corpora, and +duplicate CIDs. Missing title/section hierarchy is a warning unless the +corpus already split into articles. +""" + +from __future__ import annotations + +from dataclasses import asdict, dataclass +import re +from typing import Any + +import pandas as pd + +from .structure import has_html_tags + +SCHEMA_VERSION = "country-laws-normalize-verify/v1" + +_HTML_FAIL_FRACTION = 0.02 +_SHORT_BODY_FAIL_FRACTION = 0.50 +_MIN_BODY_CHARS = 40 + + +@dataclass(frozen=True) +class Check: + id: str + severity: str # fail | warn + passed: bool + message: str + evidence: dict[str, Any] + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + +def _bodies(corpus: pd.DataFrame) -> list[str]: + if corpus is None or corpus.empty or "body" not in corpus.columns: + return [] + return [str(x or "") for x in corpus["body"].tolist()] + + +def check_nonempty(corpus: pd.DataFrame, report: dict[str, Any]) -> Check: + n = int(len(corpus)) if corpus is not None else 0 + return Check( + id="nonempty_corpus", + severity="fail", + passed=n > 0, + message="normalized corpus has rows" if n else "normalized corpus is empty", + evidence={"n_out": n, "n_dropped": report.get("n_dropped_total")}, + ) + + +def check_entry_cids(corpus: pd.DataFrame, report: dict[str, Any]) -> Check: + if corpus is None or corpus.empty: + return Check( + id="entry_cid_unique", + severity="fail", + passed=False, + message="no entry_cid values to verify", + evidence={}, + ) + missing = int(corpus["entry_cid"].isna().sum()) if "entry_cid" in corpus.columns else int(len(corpus)) + dupes = int(corpus["entry_cid"].duplicated().sum()) if "entry_cid" in corpus.columns else 0 + empty = int((corpus["entry_cid"].astype(str).str.strip() == "").sum()) if "entry_cid" in corpus.columns else 0 + ok = missing == 0 and dupes == 0 and empty == 0 + return Check( + id="entry_cid_unique", + severity="fail", + passed=ok, + message="every row has a unique entry_cid" if ok else "missing or duplicate entry_cid", + evidence={"missing": missing, "empty": empty, "duplicate": dupes}, + ) + + +def check_no_invented_text(report: dict[str, Any]) -> Check: + flag = bool(report.get("never_invented_legal_text", False)) + return Check( + id="never_invented_legal_text", + severity="fail", + passed=flag, + message="normalizer did not invent legal text" if flag else "invented-text flag is false", + evidence={"never_invented_legal_text": flag}, + ) + + +def check_html_residual(corpus: pd.DataFrame) -> Check: + bodies = _bodies(corpus) + tagged = [b for b in bodies if has_html_tags(b)] + n = len(bodies) or 1 + fraction = len(tagged) / float(n) + passed = fraction <= _HTML_FAIL_FRACTION + return Check( + id="html_residual", + severity="fail", + passed=passed, + message=( + "HTML tags stripped from legal bodies" + if passed + else f"{len(tagged)}/{len(bodies)} bodies still contain HTML tags" + ), + evidence={ + "n_bodies": len(bodies), + "n_with_tags": len(tagged), + "fraction": fraction, + "samples": [b[:120] for b in tagged[:5]], + }, + ) + + +def check_short_bodies(corpus: pd.DataFrame) -> Check: + bodies = _bodies(corpus) + if not bodies: + return Check( + id="short_bodies", + severity="fail", + passed=False, + message="no bodies to measure", + evidence={}, + ) + short = sum(1 for b in bodies if len(b) < _MIN_BODY_CHARS) + fraction = short / float(len(bodies)) + passed = fraction <= _SHORT_BODY_FAIL_FRACTION + return Check( + id="short_bodies", + severity="fail" if not passed else "warn", + passed=passed, + message=( + "most legal units have usable body length" + if passed + else f"{short}/{len(bodies)} bodies shorter than {_MIN_BODY_CHARS} characters" + ), + evidence={"n_short": short, "n_bodies": len(bodies), "fraction": fraction}, + ) + + +def check_heading_language(corpus: pd.DataFrame, report: dict[str, Any]) -> Check: + """Warn when Latin heading dialect disagrees with the document language.""" + from .profiles import NO_LATIN_SPLIT_LANGS, iso_lang + + doc_lang = iso_lang(report.get("document_language_majority") or "") + head_lang = iso_lang(report.get("heading_language_majority") or "") + counts = report.get("heading_language_counts") or {} + if ( + doc_lang in NO_LATIN_SPLIT_LANGS + and report.get("unit") == "structured" + and head_lang + and head_lang not in NO_LATIN_SPLIT_LANGS + and head_lang != doc_lang + ): + return Check( + id="heading_language", + severity="fail", + passed=False, + message=( + f"document language {doc_lang} was split with Latin headings ({head_lang}); " + "use script-specific article markers or collector article rows" + ), + evidence={"document_language": doc_lang, "heading_counts": counts, "unit": report.get("unit")}, + ) + if doc_lang and head_lang and doc_lang != head_lang and sum(counts.values()) >= 8: + return Check( + id="heading_language", + severity="warn", + passed=True, + message=( + f"heading lexicon majority is {head_lang} but documents are {doc_lang}; " + "review samples before trusting structure" + ), + evidence={ + "document_language": doc_lang, + "heading_language": head_lang, + "heading_counts": counts, + }, + ) + return Check( + id="heading_language", + severity="warn", + passed=True, + message=( + f"heading lexicon {head_lang or 'none'} vs document language {doc_lang or 'unknown'}" + ), + evidence={ + "document_language": doc_lang, + "heading_language": head_lang, + "heading_counts": counts, + }, + ) + + +def check_structure(corpus: pd.DataFrame, report: dict[str, Any]) -> Check: + unit = str(report.get("unit") or "") + n = int(len(corpus)) if corpus is not None else 0 + structured_rows = 0 + if corpus is not None and not corpus.empty: + if "hierarchy_path" in corpus.columns: + structured_rows = int((corpus["hierarchy_path"].fillna("").astype(str).str.len() > 0).sum()) + if "record_type" in corpus.columns: + structured_rows = max( + structured_rows, + int(corpus["record_type"].isin(["article", "section"]).sum()), + ) + coverage = structured_rows / float(n) if n else 0.0 + # Article or structured units are success. Pure law-level is a warning, not a fail: + # many gazettes have no title/section markers. + if unit in {"article", "structured"} or coverage >= 0.5: + return Check( + id="legal_structure", + severity="warn", + passed=True, + message=f"retrieval units are structured ({unit}, coverage={coverage:.2f})", + evidence={"unit": unit, "structured_rows": structured_rows, "coverage": coverage}, + ) + return Check( + id="legal_structure", + severity="warn", + passed=True, + message=( + "kept whole-instrument units; no title/article/section headings detected " + "(expected for some gazettes)" + ), + evidence={"unit": unit, "structured_rows": structured_rows, "coverage": coverage}, + ) + + +def verify_normalized_corpus( + corpus: pd.DataFrame, + report: dict[str, Any], + *, + slug: str = "", +) -> dict[str, Any]: + """Run all normalization verifiers. Fail-closed on any failed `fail` check.""" + checks = [ + check_nonempty(corpus, report), + check_entry_cids(corpus, report), + check_no_invented_text(report), + check_html_residual(corpus), + check_short_bodies(corpus), + check_structure(corpus, report), + check_heading_language(corpus, report), + ] + failed = [c for c in checks if c.severity == "fail" and not c.passed] + admitted = not failed + return { + "schema_version": SCHEMA_VERSION, + "slug": slug, + "admitted": admitted, + "n_checks": len(checks), + "n_failed": len(failed), + "failed_ids": [c.id for c in failed], + "checks": [c.to_dict() for c in checks], + "blocks_graphrag": not admitted, + } + + +class NormalizationAdmissionError(RuntimeError): + """Raised when verifiers refuse to send a corpus to GraphRAG.""" + + +def verify_source(source: str) -> dict[str, Any]: + """Load a Hub/local pack, normalize, and run verifiers (no GraphRAG).""" + from .build import CACHE + from .catalog import get_country + from .normalize import build_corpus, load_source + + country = get_country(source) + local = country.get("local_source_dir") + laws, articles, source_meta = load_source(local or country["repo"], CACHE) + corpus, report = build_corpus(laws, articles, source_meta) + verdict = verify_normalized_corpus(corpus, report, slug=country["slug"]) + report["verification"] = verdict + return { + "slug": country["slug"], + "source": country["repo"], + "n_out": report.get("n_out"), + "unit": report.get("unit"), + "verification": verdict, + "drops": report.get("drops"), + } diff --git a/data/bm25/documents/part-000000.parquet b/data/bm25/documents/part-000000.parquet index 5f96c4030625a306652f178ce96672431bf7030d..8d073956d4d70f240f300e2b4e3c9f3aef6ce135 100644 --- a/data/bm25/documents/part-000000.parquet +++ b/data/bm25/documents/part-000000.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:d05a41eed41fdc6d8f53962cd7c7ef814c53aea1bea59d638400e50212e3b5de -size 289028 +oid sha256:1ada5fae09d58135ef1645f7f78dc3bdd06b1493ae20df8f8047590ac12d6a2f +size 485765 diff --git a/data/bm25/documents/part-000001.parquet b/data/bm25/documents/part-000001.parquet index 69988245598720af5afeb09b72929588be9d1cae..70eaaf26773168dba9e7953526b67db570ec703b 100644 --- a/data/bm25/documents/part-000001.parquet +++ b/data/bm25/documents/part-000001.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:71de311b333d087b48d683a248f18bef388654d36a8462205cb95b3ebe52cf4c -size 302536 +oid sha256:c5fe5409215e3118d72822421f12a454682e0f6828d2162e37995215e48ad634 +size 500552 diff --git a/data/bm25/documents/part-000002.parquet b/data/bm25/documents/part-000002.parquet index 5ae2a44fe6f17875b87e92999cc42372ac306d48..8d1516b5ef8b36ef52ae6ee770be1e99d20cbc05 100644 --- a/data/bm25/documents/part-000002.parquet +++ b/data/bm25/documents/part-000002.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:942320e8192a074199413a60f5b052002c85e42b718e4ecbd26ac80a178358e6 -size 297982 +oid sha256:5b5359219edeb4045c55fbf76ed8148d169c03a6f6aff51582b7d21236fb79b8 +size 493519 diff --git a/data/bm25/documents/part-000003.parquet b/data/bm25/documents/part-000003.parquet index 790b12a073418436e2f0e70db3d47dedbb0dd349..97149376c0b1abf4a0b7f8cb2380052ad219937d 100644 --- a/data/bm25/documents/part-000003.parquet +++ b/data/bm25/documents/part-000003.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:b1e1143b1e08779c6df60cc3f8ce66af8e2fa7cc0a06d9a39521361173825d37 -size 313164 +oid sha256:f874dd51f305437ca93c5fa0e84f311e97c5b33a4af799145df5cbbc0257ed72 +size 504590 diff --git a/data/bm25/documents/part-000004.parquet b/data/bm25/documents/part-000004.parquet index e9157f7b06f3cfc23cf1cdc1ddaeef42d3a0e429..e844b8a9ad47c38a54eccaf80642ee3c8aa7eddf 100644 --- a/data/bm25/documents/part-000004.parquet +++ b/data/bm25/documents/part-000004.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:21d20ce0c618febd1bd5b55b45f035918e5b5d7c3f7889de36cfb9a30d386607 -size 330405 +oid sha256:a94fd1bd4edec8b47f31a0d3d43aa9fac5d895914da15f31738b39850a03e6ff +size 511334 diff --git a/data/bm25/documents/part-000005.parquet b/data/bm25/documents/part-000005.parquet index 4f95fda36156a7c0f3828b891d9b91e961b820ad..84608985f1b70b1a01055092e1349a338b23f6f9 100644 --- a/data/bm25/documents/part-000005.parquet +++ b/data/bm25/documents/part-000005.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:576298055d218b1b5ca91e4c1ecfa5d7ad17bdd264f73128fa9c2293d92c23bc -size 306930 +oid sha256:1f693b1044c5963279d63a602e55c05690888810a27213bbdaabf070bc72cec7 +size 501837 diff --git a/data/bm25/documents/part-000006.parquet b/data/bm25/documents/part-000006.parquet index d26b30499d298d440ccf3a556ebf3b02abc6e802..3ed8b25b89c199f85b452b16f325b7d948856170 100644 --- a/data/bm25/documents/part-000006.parquet +++ b/data/bm25/documents/part-000006.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:25362b9b084e783f7c3f030e64c143d76ad63b30f0fe1a53aedbed11207ceed9 -size 300637 +oid sha256:6f63d9ef8337cbb98dedfb6333d6ab0b9dc3cd876f9f8fbcf2415eb85c94e937 +size 492502 diff --git a/data/bm25/documents/part-000007.parquet b/data/bm25/documents/part-000007.parquet index 9d77ccf7bf5a8155c69e3c2cea7d589d41785592..24370d68f1c2baf0178b2a0f9f0f61d502114544 100644 --- a/data/bm25/documents/part-000007.parquet +++ b/data/bm25/documents/part-000007.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:c937c0cab755f75bfbe8d54d8947ba7920a9a15ad9acb051e66d620a6453b87d -size 286983 +oid sha256:9fe10c5f024c3650781edc91b02c4a7da72bd0ca337cf5247274b48346f08b7f +size 491187 diff --git a/data/bm25/documents/part-000008.parquet b/data/bm25/documents/part-000008.parquet index d9f74c11f80441e3aa4f93294a4383ebaabc64cd..c6be9d55b21bc730be540a94c2d30991b031eafd 100644 --- a/data/bm25/documents/part-000008.parquet +++ b/data/bm25/documents/part-000008.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:dbc2e993715bedd924e334a55b849bdcb2bc306a7be4ef3ece5075ad2e3039a9 -size 298192 +oid sha256:0f8b1fa359c62f8efb1a267c0c62397e210a9cdc406b84bda7fec513926878be +size 495217 diff --git a/data/bm25/documents/part-000009.parquet b/data/bm25/documents/part-000009.parquet index 66a17fe25eb771adcde9b7477b3ad086dc3e2c28..ac5f65de7f2183dc09fe2d68b4651a14c919f2b0 100644 --- a/data/bm25/documents/part-000009.parquet +++ b/data/bm25/documents/part-000009.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:0dc5520114a60c95da2b500892ca3a9be4702220a8b55eaafe45f1a5c972e42a -size 297644 +oid sha256:01a2e1b45faab56e53d7a01cf410844be4eafe74c55fb038b47e9106e85cc80f +size 489021 diff --git a/data/bm25/documents/part-000010.parquet b/data/bm25/documents/part-000010.parquet index a3674c50211d3bb5cb93a05e519049cb4c262f77..1830f9d74e62e19a255a151cfe17d3c334134c70 100644 --- a/data/bm25/documents/part-000010.parquet +++ b/data/bm25/documents/part-000010.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:1d68a32cfbdea700642a29d4c25e728fd2394223541ad808e43aa58464bbcd08 -size 307219 +oid sha256:e850482bd3bcbc617145a72b44e17e29d47231e0b26dc4eede808b30e6af9964 +size 498169 diff --git a/data/bm25/documents/part-000011.parquet b/data/bm25/documents/part-000011.parquet index 6ee3cc1472a891c67628fdef62c6878433f2467e..b831fa29eb155155ad541eb6d5b1d36fbe7fe641 100644 --- a/data/bm25/documents/part-000011.parquet +++ b/data/bm25/documents/part-000011.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:ffd428376bc43c97f6d0fa73a145c517dc57c5da2e00eb002236508bb45cd16e -size 289955 +oid sha256:aa522d4d6a2e21e8b09b5471a778fad204bd11232b5d29820fbca5a11b2d8b2c +size 492893 diff --git a/data/bm25/documents/part-000012.parquet b/data/bm25/documents/part-000012.parquet index 29e15265be2d9d164e27e13780379c01b1a82822..cd1ea442ae52e54e794ad4da900806ac7e12ce0d 100644 --- a/data/bm25/documents/part-000012.parquet +++ b/data/bm25/documents/part-000012.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:55309b23fa015339df64dfccd4a566251bb489c7827709cd76ee4b8762dcdf0a -size 313009 +oid sha256:fa2203761e3cef8efdfa9cfb052f3a4ae30c02043280765c2eaa8c53099241ef +size 505169 diff --git a/data/bm25/documents/part-000013.parquet b/data/bm25/documents/part-000013.parquet index d24113471eaa78b24ed2b0f6242310afd0358915..bc7109477c9dcb0f51005cd2ee6fbadb9a4d8226 100644 --- a/data/bm25/documents/part-000013.parquet +++ b/data/bm25/documents/part-000013.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8e3c9d1d3e805eac5ec6d724dabbd3f63631800850a9196ff3b067664e9db707 -size 316064 +oid sha256:3ea80ce60cfd6d321c4ba909a4a0de616a2b85af7d427f775fb9660e8c883563 +size 505845 diff --git a/data/bm25/documents/part-000014.parquet b/data/bm25/documents/part-000014.parquet index 9d49c19a8f11238ce1f5dfb7ad78294f1c119155..28e85d83b1573843afc4d59243604e6c29150886 100644 --- a/data/bm25/documents/part-000014.parquet +++ b/data/bm25/documents/part-000014.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:ebc278d53b1d616dc6137ceb2996f0d99ae40a0a50468dcfbc03289fd85599ed -size 323193 +oid sha256:29897aa12312df023973dab20b209686a48d48f0e7fdc60c0b7322e854b4fb02 +size 510681 diff --git a/data/bm25/documents/part-000015.parquet b/data/bm25/documents/part-000015.parquet index a9433e1bbc2bec195421e6774011cbc6e3a58ec4..d6385796e28ecac51ba0734527863600f6c14395 100644 --- a/data/bm25/documents/part-000015.parquet +++ b/data/bm25/documents/part-000015.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:984bcf7a6317427870527f6216577a5aae2e30f47bd8ad1545dc7a9f987307a5 -size 310852 +oid sha256:24a242b100292efff447aa3782b06bc95edb7e263bcc7036e5d72bf0b62d20fb +size 503781 diff --git a/data/bm25/documents/part-000016.parquet b/data/bm25/documents/part-000016.parquet index e3b5cc2caac90cb24a6917f90e7acd885ecbd6ba..2451383e958d3d922054f979f516de879444eca3 100644 --- a/data/bm25/documents/part-000016.parquet +++ b/data/bm25/documents/part-000016.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:2778782a0e51119c74e7d1453e8875cd8abf920f0f2af62e9a6df374a93a7883 -size 310283 +oid sha256:2d75a78e2112ad28998721c636a8e717ae0f4a78550f4bd13cd263e20fa4c46c +size 504733 diff --git a/data/bm25/documents/part-000017.parquet b/data/bm25/documents/part-000017.parquet index 852306a7df7a53b5cc32c705039dfaf5fdd143f4..7f5a7ede1a9f2f4f27a4256f00e97337d1c5791a 100644 --- a/data/bm25/documents/part-000017.parquet +++ b/data/bm25/documents/part-000017.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:c4341e2e6d85a4b6014ba6f3c1d8125293b5676f0a809b4b2d0ddeaab4359cdd -size 312489 +oid sha256:c74e39b3e3d9a6b993b96d9f4cbcd4978a2a9cd1d02d672c8563ac186de6a2c2 +size 505458 diff --git a/data/bm25/documents/part-000018.parquet b/data/bm25/documents/part-000018.parquet index c25c9a1d1808631dd75c8a6358bfb2817e5dae81..175373b0442adb548415c3a9739e7c1139686cb9 100644 --- a/data/bm25/documents/part-000018.parquet +++ b/data/bm25/documents/part-000018.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:15ee12d52346962373e822b23417ba20f91f254e243adfb9a925a27f7507f13e -size 319184 +oid sha256:777187d045bb2afd4aa0e3cf3aa3b6ac0fe02959407f98940314286c57e6ad89 +size 503853 diff --git a/data/bm25/documents/part-000019.parquet b/data/bm25/documents/part-000019.parquet index 48dabb206293849ca0714121cbdab7b9d05dac18..7f98d3b286a24309cf34afe828a0f205a09b476e 100644 --- a/data/bm25/documents/part-000019.parquet +++ b/data/bm25/documents/part-000019.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:3351daeb06e98be43d8e563bc44b02df6c0082ea765b150e34619c5ae8ea0780 -size 321114 +oid sha256:acb2f36540b23ec2037b1e6ff95a40d6579d9f3de2310313684c0015ef818e22 +size 510549 diff --git a/data/bm25/documents/part-000020.parquet b/data/bm25/documents/part-000020.parquet index dcf8532cac9a46821b1763fb6cef7ec67fe4fde2..ef939f6a551c4ec0c161d709cec1cc70ba1d4ed2 100644 --- a/data/bm25/documents/part-000020.parquet +++ b/data/bm25/documents/part-000020.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:342a72be5163502c01144481e6381123805c0f23d78fe511367a91c441858d32 -size 285838 +oid sha256:fdf9523612f067bc2218a3f844732b672bc1fee1fe97e120f0e09222801ce676 +size 457111 diff --git a/data/bm25/postings/part-000000.parquet b/data/bm25/postings/part-000000.parquet index 7aa948afa39ec9c7a3e17087b648cdb7ef9a80e9..11e4c6715c864b2f523be9dc4d17e1e6b9ae2df4 100644 --- a/data/bm25/postings/part-000000.parquet +++ b/data/bm25/postings/part-000000.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:c8eb6eef0ef4f951d2cab796c8bb9026776f8986372bde523cf274c2c817f38f -size 2890673 +oid sha256:65d6b559f4c232f41ea33e9bd9322c5429e05afb3fe3273f06b6b1e6556ca273 +size 1279186 diff --git a/data/bm25/postings/part-000001.parquet b/data/bm25/postings/part-000001.parquet index 4f743a165bfb988aa1bb48569fbe0aaaf2990b3b..d55ca04f24da4fe16d717d793837702a2ceb6ab9 100644 --- a/data/bm25/postings/part-000001.parquet +++ b/data/bm25/postings/part-000001.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:d03241caeed03faacdcc2732c4c40335d33490f29c8abbaa521a0c358d8a0777 -size 2399981 +oid sha256:31c1bfcd48764824c09228e08e907d8ca73a1e69303fccec40e7667b1f100895 +size 735360 diff --git a/data/bm25/postings/part-000002.parquet b/data/bm25/postings/part-000002.parquet index 3ff119fdbe822197b0b15213c91f0e57a997d172..167db6532084f2c37c0aaa8734514ba823e8ea21 100644 --- a/data/bm25/postings/part-000002.parquet +++ b/data/bm25/postings/part-000002.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:91d1bde5b391bf8977875e0b32b140b060673ec809759d332cec2227e2f6eb0d -size 2538974 +oid sha256:4b1b538688853a1df4995baa73732b1fe51f7d866901c66277b2c8fa1434f3c7 +size 351924 diff --git a/data/bm25/postings/part-000003.parquet b/data/bm25/postings/part-000003.parquet index a10d3dd4a92dc60cb0f11436e8c6eebb07de90b6..64b88069a84613850398cbbd1e8b31c6ee9af1fd 100644 --- a/data/bm25/postings/part-000003.parquet +++ b/data/bm25/postings/part-000003.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:bd34de7ae3b59a76959f9ed74f9013d39b08a20bf01ceb2526fbefa3d9d7a23a -size 1740282 +oid sha256:61b39dc3e19668d597ae41d536306f230e939600a1d8cbc4b184c5ccb3715df2 +size 1713442 diff --git a/data/bm25/postings/part-000004.parquet b/data/bm25/postings/part-000004.parquet index c0358f828989c8ab191620285ab4b163c4fbdad9..82df1cddeedcae0327e7ab1933dbd4759b774d9d 100644 --- a/data/bm25/postings/part-000004.parquet +++ b/data/bm25/postings/part-000004.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:5314c99324be127b5f34cf4fcc95aa0d3c2632db0422fdf6cee3818679eefae2 -size 2243894 +oid sha256:3d19eec6b77d4477a8fed23911ec0040926d5bc7c4cd5ef1071ebc7e81901381 +size 1321551 diff --git a/data/bm25/postings/part-000005.parquet b/data/bm25/postings/part-000005.parquet index 5781346abe071d50457a00d65c460cc7fad39ffb..2dbbe3d688a9db686db4a028980f513bff0888bc 100644 --- a/data/bm25/postings/part-000005.parquet +++ b/data/bm25/postings/part-000005.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:4d3913af10f241b6aee584349fb7da86ae1328abfbe7a04bb15d38bdaef5fd06 -size 2690467 +oid sha256:5230a0a90a0700384b4a05a171225c5e41bf4f2866ef31fe6d8889b0df69d4cc +size 1300168 diff --git a/data/bm25/postings/part-000006.parquet b/data/bm25/postings/part-000006.parquet index 2c5a833208bca6db23278c6713efdca1e04ea3fd..debd27c1488ff7e6182ab27b8b6f2d1f97ef847d 100644 --- a/data/bm25/postings/part-000006.parquet +++ b/data/bm25/postings/part-000006.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:a08ca3affc7c9bf07eab1cb381a3b9f57d5d025ae422e4317acafb3ccbd5d3ca -size 2267172 +oid sha256:9f31651055262a42c3ad7cf0d12cb04c60116819e11db7247dc32d99d6fd8847 +size 1331255 diff --git a/data/bm25/postings/part-000007.parquet b/data/bm25/postings/part-000007.parquet index e7f903cb244435586da552c41c9787cd1019c5bb..781a345dd2c649b73b897ee7b56f3d5671f29db1 100644 --- a/data/bm25/postings/part-000007.parquet +++ b/data/bm25/postings/part-000007.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:5c6fd42c1cf8d89a5f520e406db809f53c0c7305ffc050ce99255bf6c8e6489f -size 2432017 +oid sha256:c51dadd320e183f9540d2c7a4900604f8fd561e8eefa76e67a6333bdd4226efa +size 301342 diff --git a/data/bm25/postings/part-000008.parquet b/data/bm25/postings/part-000008.parquet index 910287661dcbf874ee5667c28b2e3d1630935b31..b7c964efccd8954d0a4ab3803d996fe26e72416f 100644 --- a/data/bm25/postings/part-000008.parquet +++ b/data/bm25/postings/part-000008.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:cfc92ea303e55f3fa9700b3d464fa8c1b1bcd182aa9f578e82c47cbab8467d69 -size 358843 +oid sha256:7a1846e9b845a72bb504b46abd61cf102cfb0f0bd5958a092f81c261c3d13e2a +size 1717430 diff --git a/data/bm25/postings/part-000009.parquet b/data/bm25/postings/part-000009.parquet new file mode 100644 index 0000000000000000000000000000000000000000..d7484651563db1c94f71b733a9f375596ceac658 --- /dev/null +++ b/data/bm25/postings/part-000009.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:98037d0c1ff0b3d68f71a5c0bc52a0687306eef024794e31506f804d72f64e5a +size 1570565 diff --git a/data/bm25/postings/part-000010.parquet b/data/bm25/postings/part-000010.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fc2fe4bcec3ebccfbf703e619c8695f5ad3b03d8 --- /dev/null +++ b/data/bm25/postings/part-000010.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6c1807a583be985de9f90c1cc783fc655e058192186be7e1a00a995a8f0b984c +size 1411806 diff --git a/data/bm25/postings/part-000011.parquet b/data/bm25/postings/part-000011.parquet new file mode 100644 index 0000000000000000000000000000000000000000..0a2d677adc8194a97b94c4ffd48b5491f317396c --- /dev/null +++ b/data/bm25/postings/part-000011.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f1bc4637c59dc4335713c250ceff2dae1e9df6ad25259faf75082c6f2590b3f3 +size 505567 diff --git a/data/corpus/part-000000.parquet b/data/corpus/part-000000.parquet index f4a99e19f98e329a8c32b3326c4185c1b46ac3c8..34726b35d5a503912f60c7e1a425700038504362 100644 --- a/data/corpus/part-000000.parquet +++ b/data/corpus/part-000000.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:9ab367169c13e8a576460f0ef0a63c16b10c340d058290402b9886f045bdd592 -size 1176454 +oid sha256:2e1f71399f659b434b70283214aac226070bb1c0e803dc8c9aaa4d3c7439905d +size 1207577 diff --git a/data/corpus/part-000001.parquet b/data/corpus/part-000001.parquet index 1abf2a8db9d5916d7b9596f64dba051d87ed2d2c..9533b1a864fd05178bfd1b0e710539413fc34ab6 100644 --- a/data/corpus/part-000001.parquet +++ b/data/corpus/part-000001.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:90ee714d3c6dbe56c535231db92bb3690a7a039322093c48f41df4e80d73164e -size 1666628 +oid sha256:a340c25da2e9e690f6b4d20851e39bf9ca1242b816f76e6a60780b3b2fbaa23a +size 1735031 diff --git a/data/corpus/part-000002.parquet b/data/corpus/part-000002.parquet index 1a1f6fc97b1b578801a52170888451eb18eeb077..702eeb8bd5ede408916395de3a12ffb340ee77a5 100644 --- a/data/corpus/part-000002.parquet +++ b/data/corpus/part-000002.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8ed390f039cfc42a754a810cc9233791fc8defeb0c9051f3bc4aa493e38aebfa -size 1451640 +oid sha256:f7a8ef541a94c479e25e95184d6771dbb9a8f9a9aeeffc9c60010b5fbf4d8764 +size 1486022 diff --git a/data/corpus/part-000003.parquet b/data/corpus/part-000003.parquet index 12a75f6bdd6cc8ef6d051558bdedd8a7e6fd5bfd..a5c31bc7f600e28cf0e5b62b31fd18bad4b2519e 100644 --- a/data/corpus/part-000003.parquet +++ b/data/corpus/part-000003.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:5789bb732291e2073468919626141c05ab3218194149b41418d8189240d44d9b -size 1527877 +oid sha256:f8f66b80da09da29c48bb1501a16d7dbe7ded88f5d8561e7b2e5874ecc37dce9 +size 1571730 diff --git a/data/corpus/part-000004.parquet b/data/corpus/part-000004.parquet index c8b4c27cc64283849f146c5ed0c3d12f6854206d..cdba34b7e6e9df1b8ab9ea0930d1942c338dc2fa 100644 --- a/data/corpus/part-000004.parquet +++ b/data/corpus/part-000004.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:9cdfa627a73026f0ef9fab0bcdfbf0ff0794b05f7c58f5af7ce7c1548b869d29 -size 1428507 +oid sha256:5f675c7735c919c4aa0b3af2a5974718ca6612cb7e8201a7f819e92fb3261805 +size 1464078 diff --git a/data/corpus/part-000005.parquet b/data/corpus/part-000005.parquet index 0b7ecc23b34c13888d4e154b51905d4c38f393fa..77c0675c3d1ab194bdcbaa3415c7f086c8b3dd3e 100644 --- a/data/corpus/part-000005.parquet +++ b/data/corpus/part-000005.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:acacb46fd697094508d94e5ceb3db02a8c5fa4540f03119629d0e47790ac5690 -size 1278009 +oid sha256:b01d64f40745407172157048aec5bb1444cd646e139d18a7c0366c4ce4bb6bee +size 1309809 diff --git a/data/corpus/part-000006.parquet b/data/corpus/part-000006.parquet index 59919ecf13a6f339f8facf41fcb232216e26391c..45615d85559886d3b93726ed501e641c1da633cd 100644 --- a/data/corpus/part-000006.parquet +++ b/data/corpus/part-000006.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:b114424ec7907f888aafab7b7a8f6f1fc14d3f51a6f929cf6693bb276d57cd3f -size 1309000 +oid sha256:49f99316ffacaa4ef4a40757904caba26cc542e09567e62e65626283aa4bbf2f +size 1336583 diff --git a/data/corpus/part-000007.parquet b/data/corpus/part-000007.parquet index b16b2d592c874c20a98128399f37d0007dc3895b..93996bab683b2eab652c47fdb0a8cce930fbe9f6 100644 --- a/data/corpus/part-000007.parquet +++ b/data/corpus/part-000007.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:82500372fe090d4371da80d811f81f121639418aed1c5a13f861e8453208568f -size 1156849 +oid sha256:95c128dd38a8d1bfdde84a3662cc44c22f9ed371a1ea408434ac09c298cb369d +size 1175945 diff --git a/data/corpus/part-000008.parquet b/data/corpus/part-000008.parquet index 2d3fe008ce3e013419daa6d5a52062073d54c0f9..cf860230eb52195495d884c1e90e47d2aa463684 100644 --- a/data/corpus/part-000008.parquet +++ b/data/corpus/part-000008.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:6fc3292a5b7b5da71b0b608f219c8d35b204bcc5c22fe936ed0664892796a8e0 -size 1263578 +oid sha256:a401239a2df0ffbd9663b7498d93b325bda228b9a82a79bbd8c2782674988a23 +size 1296256 diff --git a/data/corpus/part-000009.parquet b/data/corpus/part-000009.parquet index 4c6de94d3b2e44d989fdd1463622d23fbfb47a92..dc7c91befb97505cb15222fb33860d458bbe06ed 100644 --- a/data/corpus/part-000009.parquet +++ b/data/corpus/part-000009.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:209d18c421bbe2397e3d479f6267efa864d288c417c9413f51c0f4438b5b5260 -size 1299355 +oid sha256:b0e198e646e7b77b331f70d88c798dac84879fa6bd667a502edee01618443a6e +size 1343331 diff --git a/data/corpus/part-000010.parquet b/data/corpus/part-000010.parquet index b74ea4c3453c1c2d00eaba385f913c891fe037f0..5d779a30bd1d41cd138acf6a3ae9ba85fbd4ed0c 100644 --- a/data/corpus/part-000010.parquet +++ b/data/corpus/part-000010.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:2c108825c47250b7374dde0c286fdee3de509c06b921514d5dd25a5be501a7f2 -size 1449681 +oid sha256:ef5b31060f422439f7008ff5a83f66cbc95c6dcaff6b0e6093e4687021e160f2 +size 1488115 diff --git a/data/corpus/part-000011.parquet b/data/corpus/part-000011.parquet index 2b07afa9f84da590764fca07337ebadcf5c09359..4685e9911ced4cb7a57f8c7a38bd78c6d77b0a6f 100644 --- a/data/corpus/part-000011.parquet +++ b/data/corpus/part-000011.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:6a49fd492ee37473b183d19c7d118faa93d4e04dbdb981592e4c3198cd0b49b7 -size 1274882 +oid sha256:f7fea52d5ff923f39e38b9c73c646fa8035e083200bd461457dc63fe31550b4d +size 1303028 diff --git a/data/corpus/part-000012.parquet b/data/corpus/part-000012.parquet index 8bdb2d28cdeab01e48323b256958812b5ba4d4b7..069b1c8584ea096aab35615075b43f2cbf964a51 100644 --- a/data/corpus/part-000012.parquet +++ b/data/corpus/part-000012.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:85b5c12e7d3a6d0c6436e03798bd867adfa8b37e2100c3b7afc632eaebf9e175 -size 1583045 +oid sha256:3a0ff4f1c2be30facc0baa255f6eab7d39c1afe5d4ef142193462eb86c26cf86 +size 1622434 diff --git a/data/corpus/part-000013.parquet b/data/corpus/part-000013.parquet index 7f2119ea3ab427f7c23a34b6d8cbd71867b77eaf..13f918ecae008c663cad8a01362f9402570a2fa7 100644 --- a/data/corpus/part-000013.parquet +++ b/data/corpus/part-000013.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:c7096128f380d8ad5df311fbe087794a6ade8ecb3e2421a3556476e5b21419d0 -size 1489005 +oid sha256:cee5e7f6965e6406126a300055475769dafd8825a11b2d446bf474c48699e27b +size 1538474 diff --git a/data/corpus/part-000014.parquet b/data/corpus/part-000014.parquet index 22debaaf167e8290560f7f81dc44392c814990ba..4924c2c2328d4d86990a1e09f0436c29a9499429 100644 --- a/data/corpus/part-000014.parquet +++ b/data/corpus/part-000014.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:a8f93e425708f217b9db963c35b22ade801d914e6ec389c297293f1212a73f61 -size 1544627 +oid sha256:af604d643af81b6d171fc7abea555873c178f25b312de4935067f96691e7120c +size 1590184 diff --git a/data/corpus/part-000015.parquet b/data/corpus/part-000015.parquet index 9f2def7afc8ea3f3ac2905e70a16a577f0add5c4..c0dad4a546505422658064fe744d6e0076e4bbce 100644 --- a/data/corpus/part-000015.parquet +++ b/data/corpus/part-000015.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:311ebf1b57282c8b41aadb725a17e014d2f73daa8b01ae0be447be0368d441ec -size 1593615 +oid sha256:a52f178ce0c40e5ecdd0838b3647205ced8e3b67c44e8c8bc49fb5bd17cb60d5 +size 1651190 diff --git a/data/corpus/part-000016.parquet b/data/corpus/part-000016.parquet index 1376d205931ff465094d97ae7ed99f18f902350d..226249989e2be354aeb8c6df71a8369aca1034ab 100644 --- a/data/corpus/part-000016.parquet +++ b/data/corpus/part-000016.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:78e70eadb5be28521612c6cc3ab951a92b64635fd2686299224b948ce6dd8c7a -size 1403871 +oid sha256:beeb814ad01b7eae0c198937dae38b00a7a1583203c0809f8597fa863fefbd46 +size 1447384 diff --git a/data/corpus/part-000017.parquet b/data/corpus/part-000017.parquet index 63da7938e723d61362c37326726da8b2f8f43051..99abae89b51873bf079fc2fb78c938800c4ab8a1 100644 --- a/data/corpus/part-000017.parquet +++ b/data/corpus/part-000017.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:d09fa93718ef7050ecd32435249bdd09a02a3414dd7ef50a74c47b76c0de8930 -size 1269650 +oid sha256:fb35602b4fe8d0d0776d5f79e69fabcc92f9f33afdc0a9c0e5c0b05dc06bbfc2 +size 1303865 diff --git a/data/corpus/part-000018.parquet b/data/corpus/part-000018.parquet index 180aca90cc63df0b1bbc49e496166c9f2438c9f4..6031a08636148adfbc6d88ced061b7e7ef0aa81d 100644 --- a/data/corpus/part-000018.parquet +++ b/data/corpus/part-000018.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8e0edf40d441f1085cd9c05b402e533d1c3a8eee49605e5f43281c7f44d225b2 -size 1292256 +oid sha256:cb268574d743e8ec4feb77006c81d9454d3fc2a1857a96f1f48777c1febc0a31 +size 1339978 diff --git a/data/corpus/part-000019.parquet b/data/corpus/part-000019.parquet index 21592b66571153649297bc9333e63cf52856824a..196f15ffdf4d3c802a1714548a58a828928798f0 100644 --- a/data/corpus/part-000019.parquet +++ b/data/corpus/part-000019.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:e85c869c9916dd50b1c50f73304f1d1d2429f89da39732c89f1a5a1f32a97afa -size 1243471 +oid sha256:f3e2301927c78e85f0fd05a3990db7d1e5502f1ebfba973b5fef573c71b0b336 +size 1273787 diff --git a/data/corpus/part-000020.parquet b/data/corpus/part-000020.parquet index 2d17c78367fcd04684c1fa688e70433171d50c3d..6064d4863e113ac2bca120c9a0ce0a1868cd6c26 100644 --- a/data/corpus/part-000020.parquet +++ b/data/corpus/part-000020.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:4bb84669db4a918d964d04b3f80ce42788af3742b373d5d2d34ecdb571445a5f -size 1316786 +oid sha256:e398582bc1e2cc77d0fcb82054e0d7ee9bd7f94378fb5f483d1a3b23ba929fc5 +size 1362524 diff --git a/data/graph/edges/part-000001.parquet b/data/graph/edges/part-000001.parquet index 518d2bad4076ab19fff41db32aafe56de65e29bd..543e6127231465ed46cb3fe81199826521f4f796 100644 --- a/data/graph/edges/part-000001.parquet +++ b/data/graph/edges/part-000001.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:7ada2d64b3a4f0e47b6421efab4bdfe5e2b820d803599c2b0cc3b2827c6e5d77 -size 183305 +oid sha256:88a3a7df3452efa5ffab31f48b745736d00730e99edf78060e10729807915876 +size 327199 diff --git a/data/graph/edges/part-000005.parquet b/data/graph/edges/part-000005.parquet index 1b05ae52208c166795eebdf6558045c43328c418..b931f4b73ec49349fab50ef919bbe6cd5e0388b0 100644 --- a/data/graph/edges/part-000005.parquet +++ b/data/graph/edges/part-000005.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:7d7d4937c70a3c35fcb2f7dc31f64b652f436291fd25d74c9b53383b4dc84565 -size 181530 +oid sha256:70d70405e59f61f5bc814a903ea26f2bee7182376e34a49f7f0c78e2f5db2d28 +size 326639 diff --git a/data/graph/edges/part-000009.parquet b/data/graph/edges/part-000009.parquet index 2a02751ff8ad79c3a4df2555549315cc3a39057b..d762a10d951b17bc8d3873fbc1e2c325033220d6 100644 --- a/data/graph/edges/part-000009.parquet +++ b/data/graph/edges/part-000009.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:433f0ff3073462a11117c30870911e368f11307645ba9d2c7b60c695b6645b53 -size 177980 +oid sha256:aa8da5d1239518e286ba54f03f749800378c2f37037696cade4edafb6e56becd +size 328017 diff --git a/data/graph/edges/part-000010.parquet b/data/graph/edges/part-000010.parquet index fd7f05571af9e6a91fdc2cd0b6fd9e607e4ba4bc..8a11a694aba0f4f447c2123adc6a26da05d06c95 100644 --- a/data/graph/edges/part-000010.parquet +++ b/data/graph/edges/part-000010.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:f458bd2f12824fe46f97f6aacfc3a7002a2a04544f01ef6dc1783af5f771f169 -size 176872 +oid sha256:09e97eb9dc60a1ddbfb2953a3586277a9df91a63cd03e9bb84fd54d10c13b9f0 +size 327398 diff --git a/data/graph/edges/part-000014.parquet b/data/graph/edges/part-000014.parquet index 190f69af2b07793211eebcf153891dc8fbaa9e0d..6a931bc68a65c20d68222c33903a371057e7b996 100644 --- a/data/graph/edges/part-000014.parquet +++ b/data/graph/edges/part-000014.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:d5e2bb1a139a57217f1700df360332804eb30e529475392cd11ff10609bd2486 -size 180604 +oid sha256:8324ce26a1696f0b43bd175b70070643dda6f76a99702555e8dd2ae16f723a49 +size 327594 diff --git a/data/graph/edges/part-000018.parquet b/data/graph/edges/part-000018.parquet index eff1c90b91cc13d0721162b5ea6548e956448ccf..ca38c2e5dc50f36b6d8c6974771b19386fb06c8b 100644 --- a/data/graph/edges/part-000018.parquet +++ b/data/graph/edges/part-000018.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:04f9f9e2ff87a80b2bb4790692c4a3a10d2d7f0cd510a6dd82cc73639e73ba01 -size 180510 +oid sha256:4e6ec8d5574babe217c008a43c8b19666697d699621759b52f1ea226a07bed1a +size 329035 diff --git a/data/graph/edges/part-000022.parquet b/data/graph/edges/part-000022.parquet index cb5a054118691271dce10db34c762c1e02e87a2a..bb87975c8de304a3ec27d54166c2e43afb97b967 100644 --- a/data/graph/edges/part-000022.parquet +++ b/data/graph/edges/part-000022.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:13bfe0b20feeae8917a4ea328bc5b263540cab8a08c8054fa39db27d83eb9c28 -size 179161 +oid sha256:43dc03189143e1948b669b824827384a7d12eb23b01b9a63297349b0704bf656 +size 326885 diff --git a/data/graph/edges/part-000026.parquet b/data/graph/edges/part-000026.parquet index 18f571437dd0ac3a08902192d13d5432867faabc..210f730bd261f153eaa656e4e492a7d9fc0e7c9a 100644 --- a/data/graph/edges/part-000026.parquet +++ b/data/graph/edges/part-000026.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:081501c8149cd4aae495d62723373a16ef4b296b18cbdc8eebb0e731dee5959f -size 179910 +oid sha256:e5af69f4db39795664262c79e9e3d200a52e9e63eb2cf27b95c384d6d4852ca8 +size 327366 diff --git a/data/graph/edges/part-000033.parquet b/data/graph/edges/part-000033.parquet index 25adfcbcdab7d731ce06cc8228d147be62e6a304..0684e1e61362c540d4fff413cae8b8f7666887f5 100644 --- a/data/graph/edges/part-000033.parquet +++ b/data/graph/edges/part-000033.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:1ecaca2952e9e45382e67f1aea6b337ee70eaec4f37283427c1e346ed5ae9e73 -size 179829 +oid sha256:8c08f3ae852f5b794df5ea712b7668f12020482518696a075aa9c57ec540b5e2 +size 326061 diff --git a/data/graph/edges/part-000037.parquet b/data/graph/edges/part-000037.parquet index 4017eaa81a33cff1f41b55d18596aadfbf760c99..3998ea5d182486551526d0a96c12bfee36cb0897 100644 --- a/data/graph/edges/part-000037.parquet +++ b/data/graph/edges/part-000037.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:988459876e06a85b56c67d8902d222309bcc2026a2506d2691c77ce0433b9c24 -size 178933 +oid sha256:de1d7b6734918f07fb69df30dbe3cd3ded3d830bc883a1ee6e65682512e49011 +size 326781 diff --git a/data/graph/edges/part-000043.parquet b/data/graph/edges/part-000043.parquet index da27565acaf0db2c7b123ff73e8d876f56ef4236..3a8c8e76c6a82a77482ce25af72b89d55b2fa5fc 100644 --- a/data/graph/edges/part-000043.parquet +++ b/data/graph/edges/part-000043.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:e6f503c4132d0d7c32ed97074ea99b06c67827f2309ee5496218a23d3c3ea235 -size 180437 +oid sha256:f98fcba8c29e79674720b9c092785d0515b4817cba918e639bab5cb8e2ce67a4 +size 328908 diff --git a/data/graph/edges/part-000047.parquet b/data/graph/edges/part-000047.parquet index 35d9d9c40083d13e9c11aa0e2ab765949ae9f8d1..dc2c0d4bce641a26c882c7cc0bddf4f13da7058c 100644 --- a/data/graph/edges/part-000047.parquet +++ b/data/graph/edges/part-000047.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:d56a7e6ff8165b974380b28c9afa28968f0efac6a8bcc73114ab984ba990f949 -size 179740 +oid sha256:9aa8b17a6d0eaafb29bcfa0184ab14a61770ef7ba5a352dada9ff4c0310e6326 +size 326872 diff --git a/data/graph/edges/part-000052.parquet b/data/graph/edges/part-000052.parquet index f728752077888472346793a3641025a59db412c4..6cf6aaecf535761fcb088f44ec29f250fa4e6a14 100644 --- a/data/graph/edges/part-000052.parquet +++ b/data/graph/edges/part-000052.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:d650854805e667d47beb7cbc31558acd92efaf8e6ca46861550ead7319071c7b -size 178863 +oid sha256:134c19216c5a8fdf9b0e310fa32d432cd772154bc45c637877bf285f1d02e862 +size 326351 diff --git a/data/graph/edges/part-000056.parquet b/data/graph/edges/part-000056.parquet index 1fd6d65aa3b117a34cb51f0d1ff2333729ca7ce6..df00a9ad155a2cf82846b9f5ce53cd6c502565d0 100644 --- a/data/graph/edges/part-000056.parquet +++ b/data/graph/edges/part-000056.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:647029229f736c2db07d962c5b8bedc26c97fea4df904e786a94b48735d73c07 -size 179697 +oid sha256:8f594ef70a9f121c64244869b87b30c8d7999df51fe4fe541b82cdefdf833537 +size 325820 diff --git a/data/graph/edges/part-000068.parquet b/data/graph/edges/part-000068.parquet index c5d049b5ac55da5a5589bb7e82e5665cfbc15db6..626e72ac4733e5623bdcb23fa728c3d50530bee7 100644 --- a/data/graph/edges/part-000068.parquet +++ b/data/graph/edges/part-000068.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:cee961001c68d6380f9ce18f8f0e18f7fa3ff469a83548253356c4d6ac5af9fd -size 180099 +oid sha256:806b2b94536968e271a0bb6a80402c625f6c75f3fc9af243056d7cc0ac9c8b1e +size 324897 diff --git a/data/graph/edges/part-000071.parquet b/data/graph/edges/part-000071.parquet index b99a459114e225cfc3d43877bf750811d3532107..9bc1051b5a212c9105c9293b74fcb80154dbce23 100644 --- a/data/graph/edges/part-000071.parquet +++ b/data/graph/edges/part-000071.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:43c00e6efc9f815026bce1dd914b13c2ff7e5764db6550d1fd04e018217f3de5 -size 179549 +oid sha256:d999fdb6ac781394694165137e213147b71244b3f3f2a821fe9a9c0b8ed32b98 +size 326922 diff --git a/data/graph/edges/part-000075.parquet b/data/graph/edges/part-000075.parquet index 63a1262638b7f7f450d75a77bb2c2e19f3c967df..8287ac3d6a341c8a5ac56d8cedbca3545511f0a9 100644 --- a/data/graph/edges/part-000075.parquet +++ b/data/graph/edges/part-000075.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:6545af9a957d553f7b52ae2f0e465410b5b3323f57753535f2f9003d6438bd5d -size 179752 +oid sha256:ad0f57729ac928e9678c0130655d58dd5782bce11216cc920c52f7dcd0f9d976 +size 326791 diff --git a/data/graph/edges/part-000079.parquet b/data/graph/edges/part-000079.parquet index aa54c94060c9c5de6ac0129ccce1bfafae35b4c6..f6fb353bc7c3771daf63cecf75109c7d7e03e236 100644 --- a/data/graph/edges/part-000079.parquet +++ b/data/graph/edges/part-000079.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:6f3abd0180b5a1723eca4e4f68829ecd67cd85b80b037ebdd91720fd4ea10942 -size 179395 +oid sha256:b4b9c0fc98aad9ea2c66227258aab857eb4fb98608fdd8897ee233c9f7ae7cbb +size 327416 diff --git a/data/graph/edges/part-000081.parquet b/data/graph/edges/part-000081.parquet index 8cd5c7b81b8d9f8f9deae878ea68bbb6c61e90c0..0596f141cecc488007f786472d8a9ef427e040de 100644 --- a/data/graph/edges/part-000081.parquet +++ b/data/graph/edges/part-000081.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:e797f9fbf5d258f13ad380fa3fcb073ca21bd0b0fa9fbb0c7e36042f1f3f42c1 -size 180237 +oid sha256:53c7f1c9d1beeb6f76f12b48ebd083aaef72701de5a25c760ec9f83916ee9681 +size 327427 diff --git a/data/graph/edges/part-000085.parquet b/data/graph/edges/part-000085.parquet index 80bcefa32b54a965b9fb49d7eb4db53502211fcd..08c1f28436a407d4dd30bb490e2b0bc465b3cf65 100644 --- a/data/graph/edges/part-000085.parquet +++ b/data/graph/edges/part-000085.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:6902bad0ef4cec9544ab56bb3960641fb277505e6bb41e65c913ecf277cffafd -size 177648 +oid sha256:0b3ad7c2e7c3b97e07ce8047399b4a67cdac0bfcc6922f5ced68575e4236a0c6 +size 327851 diff --git a/data/graph/edges/part-000089.parquet b/data/graph/edges/part-000089.parquet index b0e3ca54ef7e72ba75e55b727bf06bbc303b9110..742257ab3714aa3d4aafa16747bd8f4a0477e24e 100644 --- a/data/graph/edges/part-000089.parquet +++ b/data/graph/edges/part-000089.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:eef3cf172a6f95e02402bf5c73a6329729f1c074dadf5dc931dcf24585cb5c3f -size 178987 +oid sha256:4c3cf6f3b75318508fbfafeff5725505adc951cda14706f67f7d11b33724ccea +size 328535 diff --git a/data/graph/edges/part-000101.parquet b/data/graph/edges/part-000101.parquet index afbef89dc1c00d22b184fffbb87d69f9960d7526..56f930dba4cd89be3fb58cad8cb47881b8b7f16b 100644 --- a/data/graph/edges/part-000101.parquet +++ b/data/graph/edges/part-000101.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:5a0af406bef45038c61280f8000855669c1398b2032a675c431dd99b637d6462 -size 178520 +oid sha256:e2e139f4f65a569a7b3426048ccb3196be503b763c9e20d035ec5f8f68db2b55 +size 326024 diff --git a/data/graph/edges/part-000105.parquet b/data/graph/edges/part-000105.parquet index f54d698e7c7d542b3d3a56be881d5279fdff0a0b..3ab76a35f4d2ecb5753a522cfb56d21fb5f34dc9 100644 --- a/data/graph/edges/part-000105.parquet +++ b/data/graph/edges/part-000105.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:1da30badf8f77b95d5f05b3847bcc5cfa76c1c8425d4663a460bc1787aa6c79e -size 177622 +oid sha256:47ef4db379682a9a389ebb1d841088d8f7b8f7f37f70696ed5e34e58f518182f +size 325805 diff --git a/data/graph/edges/part-000109.parquet b/data/graph/edges/part-000109.parquet index 4060720b75c1be7b2903a577258f4e44b9602ce0..b129f02318228dd78a45ff169236c2d948af2a7b 100644 --- a/data/graph/edges/part-000109.parquet +++ b/data/graph/edges/part-000109.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:4b36bea62594e27036655c6a8fbe5b07064705a05cc7b78872ca6520a6060c3c -size 179775 +oid sha256:a4010881b36dd80257e2c3b95fd386b12a8855c810002d6f140f246e1f1a9cfe +size 327091 diff --git a/data/graph/edges/part-000110.parquet b/data/graph/edges/part-000110.parquet index a0746e15ad58fcc02bba5344fef38a9e7c76a1a4..653b295553b71c9f69508712981f8356720377e6 100644 --- a/data/graph/edges/part-000110.parquet +++ b/data/graph/edges/part-000110.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:182814a8f0cae45571228bfc702851cc946ab2c2b9efd8f6daa79ce8b891ae0c -size 177707 +oid sha256:4b9cb74e29ee5899ccb2b1a2518ed4add8fb845e1cbf2108202bc46576819be6 +size 327872 diff --git a/data/graph/edges/part-000114.parquet b/data/graph/edges/part-000114.parquet index 75d3fe942b2d884f997423c8cc38a0b1cb9423b6..c63db3cff13cc47ed0cdf12e7f69940b00140305 100644 --- a/data/graph/edges/part-000114.parquet +++ b/data/graph/edges/part-000114.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:fe224002f777112a86d1fbd924297c166b59ced74130ba042f8a58caf0bccd8c -size 177873 +oid sha256:88bd2f7c244fe0d5c9dd26351cdc20d76ffe1051a0738aa97c3986cc016aef3d +size 327328 diff --git a/data/graph/edges/part-000118.parquet b/data/graph/edges/part-000118.parquet index 2b5d2a3ddb49802c5fd68fe438a276d30cf2db65..471b89b7cc21757d3abb3ccd8d577ee00ba287d6 100644 --- a/data/graph/edges/part-000118.parquet +++ b/data/graph/edges/part-000118.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:ec71a554b6d0583ec24a46cc835c376ac0ef66036988ad840188ce968493ebf1 -size 178639 +oid sha256:d5bc069baa857c43c0b23a32fb8ad397bcd2a42c901f487dd250ca7e367072d1 +size 328556 diff --git a/data/graph/edges/part-000122.parquet b/data/graph/edges/part-000122.parquet index 85f9a85f712ed04544050dba65eaf155a5acf301..455f965afe14999a029492895b82cd2b1b3d5481 100644 --- a/data/graph/edges/part-000122.parquet +++ b/data/graph/edges/part-000122.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:57446a6aa412b074b478b53a5e396d401a73471b950e39ab8492e8a5abfb63b9 -size 178493 +oid sha256:ac2beb678fd26fcc2824e7d156ea85aaa5aed48c1694b98d190313e47ea1c8ed +size 327762 diff --git a/data/graph/edges/part-000126.parquet b/data/graph/edges/part-000126.parquet index 5bcf2a69c73d8a2da210661802820277b88e0c44..6d56f69fcd0d26e48b58c12e6361059bcfd0c0f5 100644 --- a/data/graph/edges/part-000126.parquet +++ b/data/graph/edges/part-000126.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:f6c9657b5a753f9549099e7cae9f90275e4cfed56ed781bc52c13beefc3d236f -size 176493 +oid sha256:48129af58e7e532eea4071970730c1e2d81283d77aab7721fd2f3c31e5c89da4 +size 328107 diff --git a/data/graph/edges/part-000133.parquet b/data/graph/edges/part-000133.parquet index 8f50686e3ab4fbcf3cde01eb413279083fe7820a..864ca6740a81747f3d7e8dc2b6d61da63d399cee 100644 --- a/data/graph/edges/part-000133.parquet +++ b/data/graph/edges/part-000133.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:bb6b9964ca4492d7c1a7181e37e2c56e4729979f9b54ed49ec574e7f4f921a2b -size 178280 +oid sha256:0eac7d27af7cc656313c1a2507452eced8820d4c122c422eee1b1a60cd5947b4 +size 328569 diff --git a/data/graph/edges/part-000137.parquet b/data/graph/edges/part-000137.parquet index e34d3edb8e423885448e9d338cf60cf125599249..11bdb2b8535a47cce6e3ee2f32af5fad41644c8e 100644 --- a/data/graph/edges/part-000137.parquet +++ b/data/graph/edges/part-000137.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:fd7fe936b5cab3b8d9825446e2f3d993ec545ccdb0ac5a15e8c99dcc66d796e9 -size 180394 +oid sha256:384e6e3cb0f44c96bf5f73d4216d6241ace3eab4ef676197b26f9e7e2948596d +size 328090 diff --git a/data/vectors/part-000000.parquet b/data/vectors/part-000000.parquet index 9d811ebcebc11d1e73f7109c1c90fbd73d452d40..32b6d554cc962d1dcc3248bdf091c354a4f91086 100644 --- a/data/vectors/part-000000.parquet +++ b/data/vectors/part-000000.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:657030f0645122aa2e74cb85c047c985057e6e7356cc240f0bbc7922df5d845b -size 7235529 +oid sha256:510335001a9ffdac1e4a1092399ee239165ce829573ab8aebeca0c385c0c48d4 +size 6655080 diff --git a/data/vectors/part-000001.parquet b/data/vectors/part-000001.parquet index 66a61f349bdc80a2892d6936af098da19005052e..c9feee53484881f4b1ebcc36e72ec3bf9cc7c60b 100644 --- a/data/vectors/part-000001.parquet +++ b/data/vectors/part-000001.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:7bd4b8dbd3ae2f9d6ff914bddda6ba4e9b6ccbd557c9e841c5ca89fc5eb54dc4 -size 7366121 +oid sha256:0df59cac38b5f3123b19d86d4e34aad814e9b8045c6709578fca3f544598f79e +size 7344726 diff --git a/data/vectors/part-000002.parquet b/data/vectors/part-000002.parquet index 56b3ada38bf2ec8bacb60b4f98d7ba94a2609a01..887c095cb9a2e15540270fcd8a3c8b6e30fd784a 100644 --- a/data/vectors/part-000002.parquet +++ b/data/vectors/part-000002.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:a48a39fb0f3f8320d1edaf752b43a0111109cff77ec44beb1da79da2d41bc517 -size 7294579 +oid sha256:edef26bc7804995ca3adc2870caf5080bcfb4e74316d3cfcb89be5814dcc40ae +size 7443541 diff --git a/data/vectors/part-000003.parquet b/data/vectors/part-000003.parquet index 4ab9ee3d8e3e906de5711b9d55040bca56002ff3..f1ca971e1a1d7df85040b3333f998d757dd1c7c3 100644 --- a/data/vectors/part-000003.parquet +++ b/data/vectors/part-000003.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:bd541e3f3485a6155257a6bd5fda7954082b427a6a03a5d48d6a94fa0dddb0ed -size 7392819 +oid sha256:246fcc6c99e885ec877eb4bd92646463b40f13767d3aa5f5286dfa50aaf3e074 +size 7488121 diff --git a/data/vectors/part-000004.parquet b/data/vectors/part-000004.parquet index f83f71179e057ee46017b46951e9e9599ebbbe42..ded928802c5ed5a4327ba58da2f5014837d800bd 100644 --- a/data/vectors/part-000004.parquet +++ b/data/vectors/part-000004.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8570452c573ec045f7c17c976c9ef02ce3d57e17fbc059d20b27dae7a89f3dd5 -size 7379817 +oid sha256:305429380eefc63483ce1d14cd2dab52b5c84a6c419c932577efa0541c99a9d0 +size 7520849 diff --git a/data/vectors/part-000005.parquet b/data/vectors/part-000005.parquet index 86e9865be54b42db1250d7304e172058e3d936c3..9999b346220b9bd4da4003b85badc89023d056e1 100644 --- a/data/vectors/part-000005.parquet +++ b/data/vectors/part-000005.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:230e717c0f7f882326b20a7d5fe9182ad075319801c3c1bc9809c54d806101a9 -size 7385933 +oid sha256:31469fff56753e16d91b6bde32ef147d31dd518fb01eac62c662b94a05170423 +size 7511827 diff --git a/data/vectors/part-000006.parquet b/data/vectors/part-000006.parquet index 591d69e07de832c1c6b15632f8b0e6902507fb21..1b38d8bc36f61fb3d72c557dfc83227cb1ba4316 100644 --- a/data/vectors/part-000006.parquet +++ b/data/vectors/part-000006.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:ebcd886d06cf49452cedf3cb92b13542a6649f286b5f10d589886533045d7b5a -size 7300812 +oid sha256:ff6919d777231a6f4826e4ce0a3ead7cb327cc3083e906d5a272c2027e3dffac +size 7478505 diff --git a/data/vectors/part-000007.parquet b/data/vectors/part-000007.parquet index 393ac8bb1d48b355f7a8c15c462dac8b3b656830..0b0226dfce08597f3341185a0c8dfb5c4f63b425 100644 --- a/data/vectors/part-000007.parquet +++ b/data/vectors/part-000007.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:54f63d9f89640770b11e290ba0eb2f578ec08d8012ee392bf9ddc357889cbfa0 -size 7375482 +oid sha256:9430f1fb7af80acd8e6af5d05dcde305c1bdac10d64f096242e237e7e9f7cfff +size 7430260 diff --git a/data/vectors/part-000008.parquet b/data/vectors/part-000008.parquet index 490d79e8412027f9a294621a9becda56d8151867..c13cfff2b1d0c45a357eb2945ac2c078324e4d2d 100644 --- a/data/vectors/part-000008.parquet +++ b/data/vectors/part-000008.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:9085135eb848d65aea071a1bc309f261fb96a76d3d7027ea743fb36ee8a7e7fb -size 7375924 +oid sha256:456d7c49f3e0692b58c4dc67b200efebae6636b3853fce07a663657b602d4714 +size 7175927 diff --git a/data/vectors/part-000009.parquet b/data/vectors/part-000009.parquet index 6b8d8eaea891860191556bc07a58d2500f4aba3b..a01168470a8629f3f3b1e0844c3e5741eb20e487 100644 --- a/data/vectors/part-000009.parquet +++ b/data/vectors/part-000009.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8abbd3b005f51a30fb7aa85f03bbc1f04ad8a8352c2949fc87564f2f2b4040e5 -size 7251880 +oid sha256:7d6dc6fe1345ec84203121f24fd3f3c690a00a44e0e8c2611e424fbdd802393f +size 7466398 diff --git a/data/vectors/part-000010.parquet b/data/vectors/part-000010.parquet index 3976ff621d8bbd175f9e796e55bd56f079923259..e3551e8e2b76836f8233745c2669aaa148f5712b 100644 --- a/data/vectors/part-000010.parquet +++ b/data/vectors/part-000010.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:89a08e362e2a4c47d71f970a0b4506040d131727336027a4492f63c8875ac35b -size 7304059 +oid sha256:73ea3b54ce15e660f5ec243bad2032bd4213a64527be3f31709098e9c93085fd +size 7359440 diff --git a/data/vectors/part-000011.parquet b/data/vectors/part-000011.parquet index ba667b2b3c1d19f8fed5b74dd032cd99d9b3ec9e..16392b2345c278d7b95e779911e3d092d736cd1a 100644 --- a/data/vectors/part-000011.parquet +++ b/data/vectors/part-000011.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:e0f5b389c3c7da9900dcb7c28922ecc9f247f26c6069042fe426de82c174c2a2 -size 7366821 +oid sha256:ead5f8cb8889f3a857bc2b587cd793a4f3b61de5c985247553f40c303ed49eae +size 7452937 diff --git a/data/vectors/part-000012.parquet b/data/vectors/part-000012.parquet index b2e321fc6f7fd1ee951b4f7a6be768957d6d777f..0739e288dca0c8148357a7ac8e6c4f6d400c9286 100644 --- a/data/vectors/part-000012.parquet +++ b/data/vectors/part-000012.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:c0214b16941c14d7947966f82719330966f93f1da9518510aae154d942eae534 -size 7389023 +oid sha256:b3c6ca0ce5dc21063a898f6f9a3dadd472330f907e9e2ff5baa29c453eb4c2ee +size 7520655 diff --git a/data/vectors/part-000013.parquet b/data/vectors/part-000013.parquet index 55ba562b01cf8a5c8a8b10cf3a4f29430f254b13..441ce96ad3a28be3c1ec3bffd317172da73d2952 100644 --- a/data/vectors/part-000013.parquet +++ b/data/vectors/part-000013.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:222b8e32fe218bb8f554588773c58fb62df2181b8067f86f7ead6f388848ed8c -size 7374818 +oid sha256:a5d9f9007d4144c9dd228931f2da638c7ba0ee666de135eadc1ee0895d06d112 +size 7485571 diff --git a/data/vectors/part-000014.parquet b/data/vectors/part-000014.parquet index 8ea89bee7c9b7eaae8bb644c6694d376e71ecf64..c9323a6fbddf32b1456eea79b9f9ba7c668bfbfc 100644 --- a/data/vectors/part-000014.parquet +++ b/data/vectors/part-000014.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:65a83b85c87b96a9b1e78eb03fc209fcf1343720efbd63a500f097160aa406a2 -size 7397630 +oid sha256:4901e85c09557644d02a55a82248b770d0180da2bb2817f002ce1721b7f4b900 +size 7506265 diff --git a/data/vectors/part-000015.parquet b/data/vectors/part-000015.parquet index 8825a622ca7a947c8d863d72536d38c74cbdd644..9446355f50cc18368580a7232f03ab6140bfc4d6 100644 --- a/data/vectors/part-000015.parquet +++ b/data/vectors/part-000015.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:00f75b1d367cad8038fde02a4b7c3ba1f0a8cf3b076d08d66b50c3d499f63ab0 -size 7349072 +oid sha256:44b3f16f66988299bda065b8cc6c79ad9e41524a3141307c3e1a15af85bfe96b +size 7505097 diff --git a/data/vectors/part-000016.parquet b/data/vectors/part-000016.parquet index d8e8c1c4dc49b795f232dc45a07c4ddff7a7910f..54cf6e63784c495de9c8c8a7f149d618a6d285cf 100644 --- a/data/vectors/part-000016.parquet +++ b/data/vectors/part-000016.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:7a24b6279ef53602148ed347aa37c1115467811ba8ee41f546afef041d3e810b -size 7376167 +oid sha256:ae010ac48acfaf54561676e1914ef59a9a02322246427aebaa7f6b8f1bfeaeed +size 7412097 diff --git a/data/vectors/part-000017.parquet b/data/vectors/part-000017.parquet index c527fc94901a2f359c6987942e012f817dae748d..aacaff180a6f55d52772dfbabbf326a73d1edab4 100644 --- a/data/vectors/part-000017.parquet +++ b/data/vectors/part-000017.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:aba0cedf14838f22e730cdfee02e48a38209ed992b7231e7c27f32617a1deebe -size 7348699 +oid sha256:1df9b926432eed748c2d8c0da7abbcec1e3d223e86ca1c6bab36386536a217a6 +size 7358729 diff --git a/data/vectors/part-000018.parquet b/data/vectors/part-000018.parquet index 379d7590eff80c77ccd610f3ebe80829b3c4390c..f831dfbd5071672e63e98280813e2f799bd63288 100644 --- a/data/vectors/part-000018.parquet +++ b/data/vectors/part-000018.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:adcb489b78d81731a4364536d97309dec527c297525f8c0fb793c56773583fe6 -size 7207304 +oid sha256:8d2a8b18ea5156ce2307eab459f6d95dab1707f03e9892c0a9af7eff0ac72c1d +size 6887911 diff --git a/data/vectors/part-000019.parquet b/data/vectors/part-000019.parquet index 161e20583e0f5c9e603f9f9b559decffbcc5aab4..26320d18b9445d3e5f9b1473f0b7a747a5eb368e 100644 --- a/data/vectors/part-000019.parquet +++ b/data/vectors/part-000019.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:b7bbb6ab4272a97c7b269cfa920863941d93fc505450c6c8821eedfb20ac3974 -size 7397401 +oid sha256:d63d01e70f5b7bf4476b417dd0719a7098c22d2f468c93979c5064209d531c08 +size 7080641 diff --git a/data/vectors/part-000020.parquet b/data/vectors/part-000020.parquet index 6b24d7d490d846d1753fe441c1973004f3e8218a..5026a4f83ef37698568b852cd2cbfc275fbf243e 100644 --- a/data/vectors/part-000020.parquet +++ b/data/vectors/part-000020.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:c0d83099daa229f78b6a8cb9ff75344b7d497b0be2cda125f862ab5e6934038e -size 6607550 +oid sha256:d740bd385805f7f162b4953acf638c787ade48b82f62d6c295060a2d8fc53702 +size 6659050 diff --git a/dataset_configs.json b/dataset_configs.json new file mode 100644 index 0000000000000000000000000000000000000000..1a266cfc31887140aaff20a14cb0e99095b3ea45 --- /dev/null +++ b/dataset_configs.json @@ -0,0 +1,14 @@ +{ + "country-laws-ir-graphrag/v1": { + "data_files": { + "corpus": "data/corpus/*.parquet", + "bm25_documents": "data/bm25/documents/*.parquet", + "bm25_postings": "data/bm25/postings/*.parquet", + "graph_nodes": "data/graph/nodes/*.parquet", + "graph_edges": "data/graph/edges/*.parquet", + "graph_adjacency_out": "data/graph/adjacency/out/*.parquet", + "graph_adjacency_in": "data/graph/adjacency/in/*.parquet", + "vectors": "data/vectors/*.parquet" + } + } +} diff --git a/indexes/bm25_document_chunks.parquet b/indexes/bm25_document_chunks.parquet index 5f39110257c849bddf095304a92e83833d71cdf8..66a84f6c78027cab448d75fa75fef25cb1efd925 100644 --- a/indexes/bm25_document_chunks.parquet +++ b/indexes/bm25_document_chunks.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:bfe7da35cc75ae8ae6c94e05860cd728bff2c306e4fc89853a68e0d009cdb68c -size 11959 +oid sha256:2cffe9b238e3b53a0b194318a5493b88203a2de6c16b9f90c927391f6b3a6fd8 +size 7624 diff --git a/indexes/bm25_keyword_shards.parquet b/indexes/bm25_keyword_shards.parquet index 5f3d0200b15b466ae34eaa47affdd695d15f58a9..6740b1dd38f787059320b304b3e8056f03896ea7 100644 --- a/indexes/bm25_keyword_shards.parquet +++ b/indexes/bm25_keyword_shards.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:ae15b9ca68e21a17a975e0e3048cf079b55dc9b245fe847c192ec468add2e501 -size 9156 +oid sha256:bfe651aba07c93bcb1434ef8e8d807f44e135dfc9c033b332b43ef201999360c +size 6199 diff --git a/indexes/corpus_chunks.parquet b/indexes/corpus_chunks.parquet index e0f6fb320a38151090a3692bc8e41680549adabb..52c85ab1909fec5cc919eb8fa95e6d3179699320 100644 --- a/indexes/corpus_chunks.parquet +++ b/indexes/corpus_chunks.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:541868ede4043940c1ca5df672414c85ef9c1de31675c11e1eafa28a038deb29 -size 11896 +oid sha256:10406e8707588c0792a752a9f562f80943b4fb7bec603208a06601eedca55aa2 +size 11783 diff --git a/indexes/graph_edge_chunks.parquet b/indexes/graph_edge_chunks.parquet index fa0e3baeeec34c49f5ad5991e46c5e77ff7b391d..4428d6261d631ef3fdda3aeb4f13a0a4355bae91 100644 --- a/indexes/graph_edge_chunks.parquet +++ b/indexes/graph_edge_chunks.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:b95d133c62c5e7ad9dd16f79a5028c93f007b6c22fa2c6bceb955f6c687618e8 -size 42816 +oid sha256:6bd0cca90f901291f40e68ca26529a54a51b6d15e2ecd49aca40608c0eca508d +size 31646 diff --git a/indexes/graph_in_adjacency.parquet b/indexes/graph_in_adjacency.parquet new file mode 100644 index 0000000000000000000000000000000000000000..655aac528b5314ca6b16a1bfb945ea81148d0725 --- /dev/null +++ b/indexes/graph_in_adjacency.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bd0aea1ee13b0f2400bff9bb494469cc3d8882043be0e2df16a89d249926e076 +size 18209 diff --git a/indexes/graph_node_chunks.parquet b/indexes/graph_node_chunks.parquet index 599ce35d61aa076cf6ab354c7fb11a4c99792ed5..ebc3abf6326943d4826a6a8809b8a9152b65204c 100644 --- a/indexes/graph_node_chunks.parquet +++ b/indexes/graph_node_chunks.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:3291ff8ad258d3fbcaa800c3f5ee756db5fadfb7c2824084f706f317da8b9b98 -size 11963 +oid sha256:bc57bde2108ea92a3a831c6ca02439376770899eee422c899a0c4fcd29029650 +size 8681 diff --git a/indexes/graph_out_adjacency.parquet b/indexes/graph_out_adjacency.parquet new file mode 100644 index 0000000000000000000000000000000000000000..5be3521c0c890645af310271a2d55a2fcc22c03b --- /dev/null +++ b/indexes/graph_out_adjacency.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dc8c92fbf2e293fbe43d1304b22544f2a2c298fab7ee83a6c34e8420874d702d +size 19845 diff --git a/indexes/vector_chunks.parquet b/indexes/vector_chunks.parquet index cda42875821925013cb597a030e4a0015297ea5f..bd020eb278eee6d665b0873197df1e9fe8c5a506 100644 --- a/indexes/vector_chunks.parquet +++ b/indexes/vector_chunks.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:92febb09ad4191f751e08a8da3ef9134f41af7174ff82ef021395db91897687d -size 111387 +oid sha256:fe5decbc2d778078ea2f98d77569d8eac94e4f102410c78cc57b3650cad9561b +size 112739 diff --git a/manifest.json b/manifest.json index edfd441a725d92678adba3013cc20ece40b5a24d..8cae9c256a17799332e089ae4272ddafa51a0120 100644 --- a/manifest.json +++ b/manifest.json @@ -1,22 +1,381 @@ { "schema_version": "country-laws-ir-graphrag/v1", + "layout_family": "skillcenter-huggingface-release/v3", + "packager_version": "0.5.0", + "primary_key": "entry_cid", + "dataset_id": "endomorphosis/ipfs_hongkong_laws", + "dataset_repo_id": "justicedao/ipfs_hongkong_laws_ir", "dataset_revision": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc", "country": { "slug": "hongkong", "repo": "endomorphosis/ipfs_hongkong_laws", "name": "Hong Kong", - "indexable": true, - "skip_reason": null, - "local_source_dir": "/workspace/country-laws-ir/cache/hongkong_filtered_e12d7058e26d", - "source_revision": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc" + "indexable": true + }, + "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.", + "bm25": { + "k1": 1.2, + "b": 0.75, + "title_weight": 5.0, + "body_weight": 1.0, + "average_document_length": 118.51053590618137, + "tokenizer": "hf-graphrag-bm25-tokens/v1", + "max_query_terms": 64, + "posting_rows_per_record": 4096, + "terms_per_shard": 4096 + }, + "counts": { + "bm25_document_chunks": 21, + "bm25_documents": 85612, + "bm25_keyword_shards": 12, + "bm25_posting_rows": 46601, + "bm25_postings": 3595440, + "bm25_terms": 46254, + "corpus_chunks": 21, + "corpus_rows": 85615, + "graph_edge_chunks": 0, + "graph_edges": 599305, + "graph_incoming_adjacency_edges": 0, + "graph_incoming_adjacency_rows": 0, + "graph_incoming_adjacency_shards": 0, + "graph_node_chunks": 0, + "graph_nodes": 89587, + "graph_outgoing_adjacency_edges": 0, + "graph_outgoing_adjacency_rows": 0, + "graph_outgoing_adjacency_shards": 0, + "vector_chunks": 21, + "vector_rows": 85615, + "n_laws": 0, + "n_articles": 85615, + "bm25_token_instances": 10145924 + }, + "parquet": { + "compression": "zstd", + "compression_level": 6, + "max_rows_per_file": 4096, + "row_group_size": 4096, + "query_engine": "duckdb" + }, + "graph": { + "adjacency_pointers_per_row": 4096, + "adjacency_pointers_per_shard": 8192, + "directions": [ + "incoming", + "outgoing" + ], + "max_remote_walk_depth": 8, + "ordering": "score_desc_nulls_last", + "edge_types": [ + "HAS_JURISDICTION", + "HAS_LANGUAGE", + "BELONGS_TO_LAW", + "HAS_ARTICLE", + "BM25_NEIGHBOR_OF" + ] + }, + "vector": { + "model_name": "thenlper/gte-small", + "dimension": 384, + "similarity": "cosine", + "assignment": "recursive_spherical_kmeans", + "layout": "semantic_centroid_groups", + "rows_sorted_by": "cosine_similarity_to_shard_centroid_desc", + "max_rows_per_chunk": 4096, + "max_rows_per_centroid": 8192, + "max_shards_per_centroid": 2, + "default_probe_centroids": 4, + "centroid_count": 32, + "shard_count": 32, + "n_vectors": 85615, + "status": "embedded" + }, + "canonical_fields": [ + "entry_cid", + "law_cid", + "record_type", + "jurisdiction", + "language", + "instrument_id", + "instrument_title", + "article_number", + "article_title", + "title", + "body", + "source_url", + "snapshot_date", + "coverage", + "license", + "collector", + "source_dataset", + "source_revision" + ], + "input_sha256": { + "laws.parquet": "a318e63b8e47c5c2600497ce2fc3688296b049cbfd9ab68acc2e2b00b6b3a772", + "articles.parquet": "6905c6e49a0b0cdaaad5191fead3950e04aa11f4f8bd4deeadd29fd610c196e8" + }, + "model_id": "thenlper/gte-small", + "cid": { + "codec": "raw", + "hash": "sha2-256", + "multibase": "base32", + "payload": "json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode('utf-8')" + }, + "normalization": { + "source_dataset": "endomorphosis/ipfs_hongkong_laws", + "source_revision": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc", + "laws_sha256": "a318e63b8e47c5c2600497ce2fc3688296b049cbfd9ab68acc2e2b00b6b3a772", + "articles_sha256": "6905c6e49a0b0cdaaad5191fead3950e04aa11f4f8bd4deeadd29fd610c196e8", + "n_laws_in": 1678, + "n_articles_in": 86041, + "unit": "article", + "article_law_coverage": 51.275923718712754, + "sparse_article_fallback": false, + "drops": { + "empty_body": 0, + "missing_instrument": 0, + "duplicate_cid": 426, + "duplicate_source_kept_first": 426 + }, + "drop_samples": { + "empty_body": [], + "missing_instrument": [], + "duplicate_cid": [ + "hk-cap109-en-sch-1-114", + "hk-cap109-en-sch-3-129", + "hk-cap109-zh-hant-sch-1-114", + "hk-cap109-zh-hant-sch-3-129", + "hk-cap112-en-sch-3-1201", + "hk-cap112-en-sch-3-726", + "hk-cap112-zh-hant-sch-1-1199", + "hk-cap112-zh-hant-sch-3-1175", + "hk-cap112-zh-hant-sch-3-1201", + "hk-cap112-zh-hant-sch-3-726", + "hk-cap156-en-sch-1-201", + "hk-cap156-en-sch-1-204", + "hk-cap156-en-sch-10-170", + "hk-cap156-en-sch-11-171", + "hk-cap156-en-sch-12-172", + "hk-cap156-en-sch-13-173", + "hk-cap156-en-sch-14-174", + "hk-cap156-en-sch-15-175", + "hk-cap156-en-sch-16-176", + "hk-cap156-en-sch-17-177" + ] + }, + "language_breakdown": { + "en": 42842, + "zh-Hant": 42773 + }, + "quality_flags": { + "articles_table_empty": false, + "sparse_article_fallback": false, + "article_law_coverage": 51.275923718712754, + "all_source_article_counts_zero": false, + "article_extraction_status_counts": { + "ok": 1586, + "missing": 92 + }, + "missing_date": false, + "missing_date_issued": true, + "eli_present": false, + "never_invented_legal_text": true, + "empty_bodies_dropped": 0, + "duplicate_cids_dropped": 426 + }, + "schema_surprises": [ + "laws.article_count dtype=int32", + "laws.date_issued is entirely null", + "laws.eli non-null=0/1678", + "laws.language values=['en', 'zh-Hant']" + ], + "n_out": 85615, + "never_invented_legal_text": true, + "n_before_dedupe": 86041, + "n_dropped_total": 426, + "record_type_breakdown": { + "article": 85615 + }, + "jurisdiction_breakdown": { + "HK": 85615 + }, + "snapshot_dates": [ + "2026-09-03" + ], + "heading_language_counts": { + "en": 22 + }, + "heading_language_majority": "en", + "document_language_majority": "en", + "verification": { + "schema_version": "country-laws-normalize-verify/v1", + "slug": "", + "admitted": true, + "n_checks": 7, + "n_failed": 0, + "failed_ids": [], + "checks": [ + { + "id": "nonempty_corpus", + "severity": "fail", + "passed": true, + "message": "normalized corpus has rows", + "evidence": { + "n_out": 85615, + "n_dropped": 426 + } + }, + { + "id": "entry_cid_unique", + "severity": "fail", + "passed": true, + "message": "every row has a unique entry_cid", + "evidence": { + "missing": 0, + "empty": 0, + "duplicate": 0 + } + }, + { + "id": "never_invented_legal_text", + "severity": "fail", + "passed": true, + "message": "normalizer did not invent legal text", + "evidence": { + "never_invented_legal_text": true + } + }, + { + "id": "html_residual", + "severity": "fail", + "passed": true, + "message": "HTML tags stripped from legal bodies", + "evidence": { + "n_bodies": 85615, + "n_with_tags": 0, + "fraction": 0.0, + "samples": [] + } + }, + { + "id": "short_bodies", + "severity": "warn", + "passed": true, + "message": "most legal units have usable body length", + "evidence": { + "n_short": 12392, + "n_bodies": 85615, + "fraction": 0.1447409916486597 + } + }, + { + "id": "legal_structure", + "severity": "warn", + "passed": true, + "message": "retrieval units are structured (article, coverage=1.00)", + "evidence": { + "unit": "article", + "structured_rows": 85615, + "coverage": 1.0 + } + }, + { + "id": "heading_language", + "severity": "warn", + "passed": true, + "message": "heading lexicon en vs document language en", + "evidence": { + "document_language": "en", + "heading_language": "en", + "heading_counts": { + "en": 22 + } + } + } + ], + "blocks_graphrag": false + } + }, + "schema_mapping": { + "laws": { + "id": "instrument_id", + "title": "instrument_title", + "text": "body", + "article_count_dtype_source": "int32" + }, + "articles": { + "id": "source_id / article identity", + "law_id": "instrument_id", + "title": "article_title", + "text": "body" + }, + "unit_policy": "prefer articles; fall back to law-level when articles empty", + "required_law_columns": [ + "id", + "title", + "text" + ], + "required_article_columns": [ + "id", + "law_id", + "title", + "text" + ], + "fail_closed": true, + "notes": "Malta and Germany share the same column names. Drift: Malta article_count is int64, Germany article_count is int32; Germany eli is often null. Identifiers are never invented. Layout matches SkillCenter HF release / publicus-ir family." + }, + "indexes": { + "bm25_document_chunks": { + "cid": "bafkreibm77u3eohdwu5awgkddcsuso4iea5c3zwbnopzbsjhhepwwotp3a", + "sha256": "2cffe9b238e3b53a0b194318a5493b88203a2de6c16b9f90c927391f6b3a6fd8", + "size_bytes": 7624, + "relative_path": "indexes/bm25_document_chunks.parquet" + }, + "bm25_keyword_shards": { + "cid": "bafkreif74zi2xid4so6lcq2o7dunqb7ujyjv37e4am5tgk2d54qbtgjwbq", + "sha256": "bfe651aba07c93bcb1434ef8e8d807f44e135dfc9c033b332b43ef201999360c", + "size_bytes": 6199, + "relative_path": "indexes/bm25_keyword_shards.parquet" + }, + "corpus_chunks": { + "cid": "bafkreiaqibxiob2yrqdzfj2svh2wf6ajio2pw67mmazaridgahxnzjk2ui", + "sha256": "10406e8707588c0792a752a9f562f80943b4fb7bec603208a06601eedca55aa2", + "size_bytes": 11783, + "relative_path": "indexes/corpus_chunks.parquet" + }, + "graph_edge_chunks": { + "cid": "bafkreidl2dgksd4qcki7idtizitffgsuuunw2fpc5tkjvssamcga5ssqru", + "sha256": "6bd0cca90f901291f40e68ca26529a54a51b6d15e2ecd49aca40608c0eca508d", + "size_bytes": 31646, + "relative_path": "indexes/graph_edge_chunks.parquet" + }, + "graph_incoming_adjacency": { + "relative_path": "indexes/graph_incoming_adjacency.parquet", + "present": false + }, + "graph_node_chunks": { + "cid": "bafkreif4k666eeeovevdvay4nsqciojxm5yithxoiiwitgqmj7gssauwka", + "sha256": "bc57bde2108ea92a3a831c6ca02439376770899eee422c899a0c4fcd29029650", + "size_bytes": 8681, + "relative_path": "indexes/graph_node_chunks.parquet" + }, + "graph_outgoing_adjacency": { + "relative_path": "indexes/graph_outgoing_adjacency.parquet", + "present": false + }, + "vector_chunks": { + "cid": "bafkreih6lxwlyllxqb4oul4y252wtwhkzfhe6ebecddyzrl3gzimvwkwdm", + "sha256": "fe5decbc2d778078ea2f98d77569d8eac94e4f102410c78cc57b3650cad9561b", + "size_bytes": 112739, + "relative_path": "indexes/vector_chunks.parquet" + } }, "source": { "source_dataset": "endomorphosis/ipfs_hongkong_laws", "source_revision": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc", - "laws_path": "/workspace/country-laws-ir/cache/hongkong_filtered_e12d7058e26d/data/laws.parquet", - "articles_path": "/workspace/country-laws-ir/cache/hongkong_filtered_e12d7058e26d/data/articles.parquet", - "laws_sha256": null, - "articles_sha256": null, + "laws_path": "/home/barberb/.ipfs_datasets/country-laws-ir/cache/hf/datasets--endomorphosis--ipfs_hongkong_laws/snapshots/e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc/data/laws.parquet", + "articles_path": "/home/barberb/.ipfs_datasets/country-laws-ir/cache/hf/datasets--endomorphosis--ipfs_hongkong_laws/snapshots/e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc/data/articles.parquet", + "laws_sha256": "a318e63b8e47c5c2600497ce2fc3688296b049cbfd9ab68acc2e2b00b6b3a772", + "articles_sha256": "6905c6e49a0b0cdaaad5191fead3950e04aa11f4f8bd4deeadd29fd610c196e8", "n_laws_source": 1678, "n_articles_source": 86041, "laws_columns": [ @@ -51,104 +410,121 @@ "record_type", "metadata_json" ], - "local_source_dir": "/workspace/country-laws-ir/cache/hongkong_filtered_e12d7058e26d", - "pack_meta": { - "slug": "hongkong", - "name": "Hong Kong", - "repo": "endomorphosis/ipfs_hongkong_laws", - "source_dataset": "endomorphosis/ipfs_hongkong_laws", - "source_revision": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc", - "filtered": true, - "filter_reason": "memsafe pass-through (chrome skipped; floor==hub; soft never-thin)", - "indexable": true, - "skip_reason": null, - "n_laws": 1678, - "n_articles": 86041 - } - }, - "counts": { - "corpus_rows": 85572, - "laws": 0, - "articles": 85572, - "bm25_documents": 85572, - "bm25_posting_rows": 33283, - "graph_nodes": 89544, - "graph_edges": 968119, - "vector_rows": 85572, - "graph_incoming_adjacency_rows": 0, - "graph_outgoing_adjacency_rows": 0 - }, - "bm25": { - "k1": 1.2, - "b": 0.75, - "title_weight": 5.0, - "body_weight": 1.0, - "average_document_length": 130.89829617164494, - "tokenizer": "fts5-unicode61-remove-diacritics-2-python/v1", - "max_query_terms": 64, - "posting_rows_per_record": 4096, - "terms_per_shard": 4096, - "n_docs": 85572, - "n_terms": 32937, - "n_posting_rows": 33283, - "n_postings": 3544157 + "article_count_dtype": "int32", + "schema_surprises": [ + "laws.article_count dtype=int32", + "laws.date_issued is entirely null", + "laws.eli non-null=0/1678", + "laws.language values=['en', 'zh-Hant']" + ] }, - "graph": { - "n_nodes": 89544, - "n_edges": 968119, - "n_doc_nodes": 87158, - "n_facet_nodes": 2386, - "edge_types": [ - "ARTICLE_OF", - "BM25_NEIGHBOR_OF", - "HAS_INSTRUMENT", - "HAS_JURISDICTION", - "HAS_LANGUAGE", - "HAS_SOURCE", - "HAS_STATUS", - "IDENTIFIED_BY", - "IDENTIFIED_BY_ELI" - ], - "adjacency": "empty_placeholder_oom_avoidance" - }, - "vector": { - "model_name": "thenlper/gte-small", - "dimension": 384, - "similarity": "cosine", - "assignment": "sequential_shards", - "layout": "semantic_centroid_groups", - "rows_sorted_by": "cosine_similarity_to_shard_centroid_desc", - "max_rows_per_chunk": 4096, - "n_vectors": 85572, - "centroid_count": 21, - "shard_count": 21, - "status": "embedded", - "via": "layout_vectors_memsafe_sequential" - }, - "normalization": { - "source_dataset": "endomorphosis/ipfs_hongkong_laws", + "incremental": { + "kind": "full_rebuild", + "mode": "auto", + "reason": "operator forced full rebuild", "source_revision": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc", - "n_laws_in": 1678, - "n_articles_in": 86041, - "unit": "article", - "drops": { - "empty_body": 0, - "missing_instrument": 0, - "duplicate_cid": 469 + "prior_revision": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc", + "source_fingerprint": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc|a318e63b8e47c5c2600497ce2fc3688296b049cbfd9ab68acc2e2b00b6b3a772|6905c6e49a0b0cdaaad5191fead3950e04aa11f4f8bd4deeadd29fd610c196e8", + "prior_fingerprint": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc||", + "delta": { + "n_added": 71514, + "n_removed": 71471, + "n_unchanged": 14101, + "prior_count": 85572, + "current_count": 85615, + "changed_ratio": 0.8352975529988904, + "equivalent_to_full": false, + "added_cids_sample": [ + "bafkreia224uirwbtfjv4mapie3ag7v27ntrgnqhlcq4hadi7e2th3xamye", + "bafkreia227miown5wpqxydaohzwcjqfzfbi6cqi343hctaylmw3bcw2hhq", + "bafkreia227tx7byszabxaxpyz2nukmqjsq6yxfyjm4shnqicrv426za7rm", + "bafkreia22c4whfcqjvrwf5fbsdup4ylmyroldza2wnsxdkixkv2ow36sm4", + "bafkreia22hcwnxp7rsj4lcrkweuwetsaz5uboqumyzehfh7uikzrfcg62i", + "bafkreia22hehel7wwi6qoim27yklrrfr4rble2i2xgeasrz7deeuhhvgbi", + "bafkreia22kovzznmke62vrwbziy5l7pzkotxubbt5ckd3r63oflu2aruoi", + "bafkreia22s3o33vnjtlqepubq4dllbq4ud5gain3fgdfd3kbxpoddfi43a" + ], + "removed_cids_sample": [ + "bafkreia223owj6vdy2ea6vsfrfbjuv2tbbm4bqnywj3iwhaxia4czp655e", + "bafkreia22aivsw6fkl6nlx6v7z2z7rwdrjkmyzwjvapfejtrxnt3zs53ca", + "bafkreia22auocbra4ynjedn7hdyd7jzku7gkp75fwgncrqcjkyi2a6ehda", + "bafkreia22ea64jdcgy5ccaus33ddy3ieaui6nntwgiadupgnvdtrl4uopu", + "bafkreia22iemhnffy76bs7xhuagbrcvuzi7ex4kki2hsi7nfzbxpjodow4", + "bafkreia22od22sl7ktwzpi4vck45wxl5sesj32xu3hsmp6wpkgyztfxelu", + "bafkreia22pjgp4k3lfyvu7tkqhmdbmajikse5ton7pookyg667as4a6k5a", + "bafkreia22pph2fydtnhp2u75qtchxnne5yudaotbpnopy5nqccrrhc2nzq" + ] }, - "n_out": 85572, - "n_dropped_total": 469, - "via": "hongkong_corpus_stream", - "record_type_breakdown": { - "article": 85572 + "reuse_embeddings": false, + "skip_build": false, + "equivalent_to_full": true, + "schema_version": "country-laws-ir-graphrag/v1", + "vectors": { + "n_docs": 85615, + "n_reused": 0, + "n_encoded": 85615, + "n_missing": 0, + "model_name": "thenlper/gte-small", + "model_revision": "17e1f347d17fe144873b1201da91788898c639cd", + "dimension": 384, + "status": "merged", + "device": "cuda", + "device_fallback": false + } + }, + "sparse": { + "engine": "hf_graphrag", + "schema_version": "country-laws-ir-graphrag/v1", + "bm25": { + "bm25": { + "average_document_length": 118.51053590618137, + "b": 0.75, + "body_weight": 1.0, + "k1": 1.2, + "max_query_terms": 64, + "posting_rows_per_record": 4096, + "terms_per_shard": 4096, + "title_weight": 5.0, + "tokenizer": "hf-graphrag-bm25-tokens/v1" + }, + "configs": { + "bm25_documents": "data/bm25/documents/*.parquet", + "bm25_postings": "data/bm25/postings/*.parquet", + "bm25_keyword_index": "indexes/bm25_keyword_shards.parquet" + }, + "counts": { + "bm25_document_chunks": 21, + "bm25_documents": 85612, + "bm25_keyword_shards": 12, + "bm25_posting_rows": 46601, + "bm25_postings": 3595440, + "bm25_terms": 46254, + "bm25_token_instances": 10145924 + }, + "indexes": { + "bm25_document_chunks": { + "cid": "bafkreibm77u3eohdwu5awgkddcsuso4iea5c3zwbnopzbsjhhepwwotp3a", + "relative_path": "indexes/bm25_document_chunks.parquet", + "row_count": 21, + "sha256": "2cffe9b238e3b53a0b194318a5493b88203a2de6c16b9f90c927391f6b3a6fd8", + "size_bytes": 7624 + }, + "bm25_keyword_shards": { + "cid": "bafkreif74zi2xid4so6lcq2o7dunqb7ujyjv37e4am5tgk2d54qbtgjwbq", + "relative_path": "indexes/bm25_keyword_shards.parquet", + "row_count": 12, + "sha256": "bfe651aba07c93bcb1434ef8e8d807f44e135dfc9c033b332b43ef201999360c", + "size_bytes": 6199 + } + }, + "schema_version": "hf-graphrag-bm25-layout/v1" }, - "language_breakdown": { - "en": 42799, - "zh-Hant": 42773 + "graph": { + "node_count": 89587, + "edge_count": 599305, + "adjacency": "data/graph/adjacency/{out,in}/*.parquet" }, - "never_invented_legal_text": true - }, - "neighbor_via": "sqlite_fts", - "built_utc": "2026-09-10T09:47:09.900133+00:00", - "via": "hongkong_package_stream_graph" + "sqlite": false, + "query_engine": "duckdb" + } } diff --git a/normalization_report.json b/normalization_report.json new file mode 100644 index 0000000000000000000000000000000000000000..2b9423d9f359b609fc3665ef19e12cbbb6269898 --- /dev/null +++ b/normalization_report.json @@ -0,0 +1,175 @@ +{ + "source_dataset": "endomorphosis/ipfs_hongkong_laws", + "source_revision": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc", + "laws_sha256": "a318e63b8e47c5c2600497ce2fc3688296b049cbfd9ab68acc2e2b00b6b3a772", + "articles_sha256": "6905c6e49a0b0cdaaad5191fead3950e04aa11f4f8bd4deeadd29fd610c196e8", + "n_laws_in": 1678, + "n_articles_in": 86041, + "unit": "article", + "article_law_coverage": 51.275923718712754, + "sparse_article_fallback": false, + "drops": { + "empty_body": 0, + "missing_instrument": 0, + "duplicate_cid": 426, + "duplicate_source_kept_first": 426 + }, + "drop_samples": { + "empty_body": [], + "missing_instrument": [], + "duplicate_cid": [ + "hk-cap109-en-sch-1-114", + "hk-cap109-en-sch-3-129", + "hk-cap109-zh-hant-sch-1-114", + "hk-cap109-zh-hant-sch-3-129", + "hk-cap112-en-sch-3-1201", + "hk-cap112-en-sch-3-726", + "hk-cap112-zh-hant-sch-1-1199", + "hk-cap112-zh-hant-sch-3-1175", + "hk-cap112-zh-hant-sch-3-1201", + "hk-cap112-zh-hant-sch-3-726", + "hk-cap156-en-sch-1-201", + "hk-cap156-en-sch-1-204", + "hk-cap156-en-sch-10-170", + "hk-cap156-en-sch-11-171", + "hk-cap156-en-sch-12-172", + "hk-cap156-en-sch-13-173", + "hk-cap156-en-sch-14-174", + "hk-cap156-en-sch-15-175", + "hk-cap156-en-sch-16-176", + "hk-cap156-en-sch-17-177" + ] + }, + "language_breakdown": { + "en": 42842, + "zh-Hant": 42773 + }, + "quality_flags": { + "articles_table_empty": false, + "sparse_article_fallback": false, + "article_law_coverage": 51.275923718712754, + "all_source_article_counts_zero": false, + "article_extraction_status_counts": { + "ok": 1586, + "missing": 92 + }, + "missing_date": false, + "missing_date_issued": true, + "eli_present": false, + "never_invented_legal_text": true, + "empty_bodies_dropped": 0, + "duplicate_cids_dropped": 426 + }, + "schema_surprises": [ + "laws.article_count dtype=int32", + "laws.date_issued is entirely null", + "laws.eli non-null=0/1678", + "laws.language values=['en', 'zh-Hant']" + ], + "n_out": 85615, + "never_invented_legal_text": true, + "n_before_dedupe": 86041, + "n_dropped_total": 426, + "record_type_breakdown": { + "article": 85615 + }, + "jurisdiction_breakdown": { + "HK": 85615 + }, + "snapshot_dates": [ + "2026-09-03" + ], + "heading_language_counts": { + "en": 22 + }, + "heading_language_majority": "en", + "document_language_majority": "en", + "verification": { + "schema_version": "country-laws-normalize-verify/v1", + "slug": "", + "admitted": true, + "n_checks": 7, + "n_failed": 0, + "failed_ids": [], + "checks": [ + { + "id": "nonempty_corpus", + "severity": "fail", + "passed": true, + "message": "normalized corpus has rows", + "evidence": { + "n_out": 85615, + "n_dropped": 426 + } + }, + { + "id": "entry_cid_unique", + "severity": "fail", + "passed": true, + "message": "every row has a unique entry_cid", + "evidence": { + "missing": 0, + "empty": 0, + "duplicate": 0 + } + }, + { + "id": "never_invented_legal_text", + "severity": "fail", + "passed": true, + "message": "normalizer did not invent legal text", + "evidence": { + "never_invented_legal_text": true + } + }, + { + "id": "html_residual", + "severity": "fail", + "passed": true, + "message": "HTML tags stripped from legal bodies", + "evidence": { + "n_bodies": 85615, + "n_with_tags": 0, + "fraction": 0.0, + "samples": [] + } + }, + { + "id": "short_bodies", + "severity": "warn", + "passed": true, + "message": "most legal units have usable body length", + "evidence": { + "n_short": 12392, + "n_bodies": 85615, + "fraction": 0.1447409916486597 + } + }, + { + "id": "legal_structure", + "severity": "warn", + "passed": true, + "message": "retrieval units are structured (article, coverage=1.00)", + "evidence": { + "unit": "article", + "structured_rows": 85615, + "coverage": 1.0 + } + }, + { + "id": "heading_language", + "severity": "warn", + "passed": true, + "message": "heading lexicon en vs document language en", + "evidence": { + "document_language": "en", + "heading_language": "en", + "heading_counts": { + "en": 22 + } + } + } + ], + "blocks_graphrag": false + } +} diff --git a/normalize.py b/normalize.py new file mode 100644 index 0000000000000000000000000000000000000000..b3c348f675dd13ca6f9184c6ffffce5cdfead2d8 --- /dev/null +++ b/normalize.py @@ -0,0 +1,704 @@ +"""Normalize endomorphosis/ipfs_*_laws into a CID-keyed canonical corpus. + +Prefer article/section as the retrieval unit; fall back to law-level when +articles are missing or empty. Strip leftover HTML, then detect multilingual +title/chapter/article/section headings (Oregon-style) when present. Never +invent legal text or a hierarchy that is not in the source. + +Public Hub reads only (token=False). No Hugging Face token is read or stored. +""" + +from __future__ import annotations + +import json +import os +from collections import Counter +from pathlib import Path +from typing import Any + +import pandas as pd +from huggingface_hub import dataset_info, hf_hub_download +from huggingface_hub.errors import EntryNotFoundError + +from . import ENTRY_IDENTITY_SCHEMA, LAW_IDENTITY_SCHEMA, SCHEMA_VERSION +from .auth import configure_hf, public_token +from .cidutil import cid_of_json, sha256_file, sha256_hex +from .schema import SchemaError, validate_articles, validate_laws +from .structure import normalize_legal_text, split_structured_units + +COLLECTOR_DEFAULT = "endomorphosis/ipfs_datasets_py" +EMPTY_ARTICLE_COLUMNS = ( + "law_id", + "id", + "title", + "text", + "source_url", + "document_number", + "article_number", + "record_type", + "metadata_json", +) + + +def _empty_articles() -> pd.DataFrame: + return pd.DataFrame(columns=list(EMPTY_ARTICLE_COLUMNS)) + + +def normalize_text(value: Any) -> str: + if value is None or (isinstance(value, float) and pd.isna(value)): + return "" + return normalize_legal_text(value) + + +def _s(value: Any) -> str: + return normalize_text(value) + + +def _download(repo_id: str, filename: str, cache_dir: Path) -> Path: + configure_hf() + path = hf_hub_download( + repo_id=repo_id, + filename=filename, + repo_type="dataset", + token=public_token(), + cache_dir=str(cache_dir / "hf"), + ) + return Path(path) + + +def _repo_filenames(info: Any) -> set[str]: + return {str(getattr(s, "rfilename", "") or "") for s in (getattr(info, "siblings", None) or [])} + + +def _pick_repo_file(filenames: set[str], name: str) -> str | None: + for cand in (f"data/{name}.parquet", f"{name}.parquet"): + if cand in filenames: + return cand + return None + + +def _resolve_local_parquet(root: Path, name: str, *, required: bool = True) -> Path | None: + """Accept either <root>/data/<name>.parquet or <root>/<name>.parquet.""" + for cand in (root / "data" / f"{name}.parquet", root / f"{name}.parquet"): + if cand.is_file(): + return cand + if required: + raise FileNotFoundError(f"missing {name}.parquet under {root} (tried data/ and root)") + return None + + +def load_local_source(local_dir: Path) -> tuple[pd.DataFrame, pd.DataFrame, dict[str, Any]]: + """Load a local country-laws pack (filtered preprocess layout).""" + local_dir = Path(local_dir).resolve() + laws_path = _resolve_local_parquet(local_dir, "laws") + articles_path = _resolve_local_parquet(local_dir, "articles", required=False) + laws = pd.read_parquet(laws_path) + articles = pd.read_parquet(articles_path) if articles_path is not None else _empty_articles() + validate_laws(laws) + validate_articles(articles) + pack_meta: dict[str, Any] = {} + meta_path = local_dir / "pack_meta.json" + if meta_path.is_file(): + try: + pack_meta = json.loads(meta_path.read_text(encoding="utf-8")) + except Exception: + pack_meta = {} + source_dataset = ( + pack_meta.get("source_dataset") + or pack_meta.get("repo") + or f"local/{local_dir.name}" + ) + source_revision = str( + pack_meta.get("source_revision") + or pack_meta.get("revision") + or f"local:{local_dir.name}" + ) + meta = { + "source_dataset": source_dataset, + "source_revision": source_revision, + "laws_path": str(laws_path), + "articles_path": str(articles_path) if articles_path is not None else None, + "laws_sha256": sha256_file(laws_path), + "articles_sha256": sha256_file(articles_path) if articles_path is not None else None, + "n_laws_source": int(len(laws)), + "n_articles_source": int(len(articles)), + "laws_columns": list(map(str, laws.columns)), + "articles_columns": list(map(str, articles.columns)), + "article_count_dtype": str(laws["article_count"].dtype) if "article_count" in laws.columns else None, + "schema_surprises": _schema_surprises(laws, articles), + "local_source_dir": str(local_dir), + "pack_meta": pack_meta, + } + return laws, articles, meta + + +def load_source(repo_id: str, cache_dir: Path) -> tuple[pd.DataFrame, pd.DataFrame, dict[str, Any]]: + """Load Hub dataset id OR a local directory with laws/articles parquet.""" + local = Path(repo_id) + if local.is_dir() and ( + (local / "data" / "laws.parquet").is_file() or (local / "laws.parquet").is_file() + ): + return load_local_source(local) + + configure_hf() + os.environ.setdefault("HF_HOME", str(cache_dir / "hf")) + info = dataset_info(repo_id, token=public_token()) + revision = info.sha + filenames = _repo_filenames(info) + laws_file = _pick_repo_file(filenames, "laws") or "data/laws.parquet" + articles_file = _pick_repo_file(filenames, "articles") + laws_path = _download(repo_id, laws_file, cache_dir) + articles_path: Path | None = None + if articles_file is not None: + try: + articles_path = _download(repo_id, articles_file, cache_dir) + except EntryNotFoundError: + articles_path = None + laws = pd.read_parquet(laws_path) + articles = pd.read_parquet(articles_path) if articles_path is not None else _empty_articles() + validate_laws(laws) + validate_articles(articles) + meta = { + "source_dataset": repo_id, + "source_revision": revision, + "laws_path": str(laws_path), + "articles_path": str(articles_path) if articles_path is not None else None, + "laws_sha256": sha256_file(laws_path), + "articles_sha256": sha256_file(articles_path) if articles_path is not None else None, + "n_laws_source": int(len(laws)), + "n_articles_source": int(len(articles)), + "laws_columns": list(map(str, laws.columns)), + "articles_columns": list(map(str, articles.columns)), + "article_count_dtype": str(laws["article_count"].dtype) if "article_count" in laws.columns else None, + "schema_surprises": _schema_surprises(laws, articles), + } + return laws, articles, meta + + +def _schema_surprises(laws: pd.DataFrame, articles: pd.DataFrame) -> list[str]: + notes: list[str] = [] + if articles is None or articles.empty: + notes.append("articles.parquet has 0 rows; corpus falls back to law-level units") + if "article_count" in laws.columns: + dtype = str(laws["article_count"].dtype) + notes.append(f"laws.article_count dtype={dtype}") + try: + if int((laws["article_count"].fillna(0) == 0).sum()) == len(laws): + notes.append("every law has article_count=0") + except Exception: + pass + for col in ("date", "date_issued"): + if col in laws.columns and laws[col].isna().all(): + notes.append(f"laws.{col} is entirely null") + if "eli" in laws.columns: + n_eli = int(laws["eli"].notna().sum()) if hasattr(laws["eli"], "notna") else 0 + notes.append(f"laws.eli non-null={n_eli}/{len(laws)}") + if "language" in laws.columns: + langs = sorted({str(x) for x in laws["language"].dropna().unique()}) + notes.append(f"laws.language values={langs}") + return notes + + +def _parse_meta(raw: str) -> dict[str, Any]: + if not raw: + return {} + try: + obj = json.loads(raw) + return obj if isinstance(obj, dict) else {} + except Exception: + return {} + + +def _law_cid(instrument_id: str, instrument_title: str, jurisdiction: str, language: str, source_dataset: str) -> str: + identity = { + "schema": LAW_IDENTITY_SCHEMA, + "source_dataset": source_dataset, + "instrument_id": instrument_id, + "instrument_title": instrument_title, + "jurisdiction": jurisdiction, + "language": language, + } + return cid_of_json(identity) + + +def _entry_cid(record: dict[str, Any]) -> str: + identity = { + "schema": ENTRY_IDENTITY_SCHEMA, + "record_type": record["record_type"], + "source_dataset": record["source_dataset"], + "instrument_id": record["instrument_id"], + "article_number": record.get("article_number") or "", + "article_title": record.get("article_title") or "", + "body_sha256": record["body_sha256"], + "language": record.get("language") or "", + "jurisdiction": record.get("jurisdiction") or "", + "source_url": record.get("source_url") or "", + } + return cid_of_json(identity) + + +def _row_get(row: pd.Series, col: str, default: str = "") -> str: + if col not in row.index: + return default + return _s(row[col]) + + +def _coverage_from( + row: pd.Series, + meta: dict[str, Any], + articles_empty: bool, + sparse_fallback: bool = False, +) -> str: + for key in ("coverage", "coverage_note"): + if key in meta and meta[key]: + return normalize_text(meta[key]) + status = normalize_text(meta.get("article_extraction_status") or "") + if sparse_fallback: + note = "law-level (article coverage below 10% of laws; sparse articles table)" + if status: + return f"{note}; extraction_status={status}" + return note + if articles_empty: + if status: + return f"law-level (articles empty or unavailable in source snapshot); extraction_status={status}" + return "law-level (articles empty or unavailable in source snapshot)" + if status: + return f"article-level; extraction_status={status}" + return "article-level" + + +def _snapshot_date(row: pd.Series, meta: dict[str, Any], source_meta: dict[str, Any]) -> str: + for col in ("retrieved_at", "date_issued", "date"): + val = _row_get(row, col) + if val: + return val[:10] if len(val) >= 10 and val[4] == "-" else val + for key in ("snapshot_date", "retrieved_at"): + if key in meta and meta[key]: + return normalize_text(str(meta[key]))[:10] + nested = meta.get("metadata") if isinstance(meta.get("metadata"), dict) else {} + for key in ("snapshot_date", "retrieved_at"): + if nested.get(key): + return normalize_text(str(nested[key]))[:10] + return "" + + +def _hierarchy_fields( + title: str, body: str, article_number: str, *, language: str = "" +) -> dict[str, Any]: + """Best-effort hierarchy from a single already-split article/section body.""" + units = split_structured_units( + f"{title}\n{body}" if title else body, language=language + ) + if not units: + return { + "hierarchy_kind": "article" if article_number else "law", + "hierarchy_path": "", + "title_number": "", + "chapter_number": "", + "part_number": "", + "section_number": "", + "subsections": [], + } + unit = units[0] + return { + "hierarchy_kind": unit.kind, + "hierarchy_path": unit.hierarchy_path, + "title_number": unit.title_number, + "chapter_number": unit.chapter_number, + "part_number": unit.part_number, + "section_number": unit.section_number, + "subsections": list(unit.subsections), + } + + +def _collector(meta: dict[str, Any], source_dataset: str) -> str: + nested = meta.get("metadata") if isinstance(meta.get("metadata"), dict) else {} + for blob in (meta, nested): + for key in ("collector", "collector_id", "harvester"): + if blob.get(key): + return normalize_text(blob[key]) + return f"{COLLECTOR_DEFAULT} ({source_dataset})" + + +def laws_index(laws: pd.DataFrame, source_dataset: str) -> dict[str, dict[str, Any]]: + """Map instrument_id -> law facet fields (always computed; not always corpus units).""" + out: dict[str, dict[str, Any]] = {} + for _, row in laws.iterrows(): + instrument_id = _row_get(row, "id") + instrument_title = _row_get(row, "title") + jurisdiction = _row_get(row, "jurisdiction") or _row_get(row, "country") + language = _row_get(row, "language") + law_cid = _law_cid(instrument_id, instrument_title, jurisdiction, language, source_dataset) + meta = _parse_meta(_row_get(row, "metadata_json")) + out[instrument_id] = { + "instrument_id": instrument_id, + "instrument_title": instrument_title, + "law_cid": law_cid, + "jurisdiction": jurisdiction, + "language": language, + "source_url": _row_get(row, "source_url"), + "license": _row_get(row, "license"), + "eli": _row_get(row, "eli"), + "identifier": _row_get(row, "identifier") or instrument_id, + "official_identifier": _row_get(row, "official_identifier"), + "source_type": _row_get(row, "source_type"), + "country": _row_get(row, "country"), + "law_status": _row_get(row, "law_status"), + "body": _row_get(row, "text"), + "metadata": meta, + "row": row, + } + return out + + +def _base_record( + *, + record_type: str, + source_dataset: str, + source_revision: str, + instrument_id: str, + instrument_title: str, + law_cid: str, + article_number: str, + article_title: str, + body: str, + jurisdiction: str, + language: str, + source_url: str, + snapshot_date: str, + coverage: str, + license_expr: str, + collector: str, + source_id: str, + extra: dict[str, Any] | None = None, +) -> dict[str, Any]: + title_for_bm25 = article_title if record_type == "article" and article_title else instrument_title + rec: dict[str, Any] = { + "record_type": record_type, + "source_dataset": source_dataset, + "source_revision": source_revision, + "source_id": source_id, + "instrument_id": instrument_id, + "instrument_title": instrument_title, + "law_id": instrument_id, + "law_cid": law_cid, + "article_number": article_number, + "article_title": article_title, + "title": title_for_bm25, + "body": body, + "body_sha256": sha256_hex(body.encode("utf-8")), + "jurisdiction": jurisdiction, + "language": language, + "source_url": source_url, + "snapshot_date": snapshot_date, + "coverage": coverage, + "license": license_expr, + "collector": collector, + "schema_version": SCHEMA_VERSION, + "entry_identity_schema_version": ENTRY_IDENTITY_SCHEMA, + } + if extra: + rec.update(extra) + rec["entry_cid"] = _entry_cid(rec) + rec["title_length"] = len(title_for_bm25) + rec["body_length"] = len(body) + rec["document_length"] = len(title_for_bm25) + len(body) + return rec + + +def build_corpus( + laws: pd.DataFrame, + articles: pd.DataFrame, + source_meta: dict[str, Any], +) -> tuple[pd.DataFrame, dict[str, Any]]: + source_dataset = source_meta["source_dataset"] + source_revision = source_meta["source_revision"] + law_map = laws_index(laws, source_dataset) + articles_empty = articles is None or articles.empty + n_laws = int(len(laws)) + n_arts = int(len(articles) if articles is not None else 0) + article_law_coverage = (n_arts / n_laws) if n_laws else 0.0 + # Empty articles.parquet already falls back. Also fall back when the table is + # present but covers under ~10% as many rows as laws (Estonia: 2 vs 3484). + sparse_fallback = (not articles_empty) and article_law_coverage < 0.10 + use_articles = (not articles_empty) and not sparse_fallback + + extraction_statuses: Counter[str] = Counter() + for parent in law_map.values(): + st = normalize_text(parent["metadata"].get("article_extraction_status") or "") + if st: + extraction_statuses[st] += 1 + + report: dict[str, Any] = { + "source_dataset": source_dataset, + "source_revision": source_revision, + "laws_sha256": source_meta.get("laws_sha256"), + "articles_sha256": source_meta.get("articles_sha256"), + "n_laws_in": int(len(laws)), + "n_articles_in": int(len(articles) if articles is not None else 0), + "unit": "article" if use_articles else "law", + "article_law_coverage": article_law_coverage, + "sparse_article_fallback": sparse_fallback, + "drops": { + "empty_body": 0, + "missing_instrument": 0, + "duplicate_cid": 0, + "duplicate_source_kept_first": 0, + }, + "drop_samples": { + "empty_body": [], + "missing_instrument": [], + "duplicate_cid": [], + }, + "language_breakdown": {}, + "quality_flags": {}, + "schema_surprises": list(source_meta.get("schema_surprises") or []), + "n_out": 0, + "never_invented_legal_text": True, + } + + entries: list[dict[str, Any]] = [] + + if sparse_fallback: + report["schema_surprises"].append( + f"article coverage {article_law_coverage:.4f} < 0.10 of laws; falling back to law-level units" + ) + + if use_articles: + for _, row in articles.iterrows(): + source_id = _row_get(row, "id") + instrument_id = _row_get(row, "law_id") + body = _row_get(row, "text") + article_title = _row_get(row, "title") + article_number = _row_get(row, "article_number") + if not body: + report["drops"]["empty_body"] += 1 + if len(report["drop_samples"]["empty_body"]) < 20: + report["drop_samples"]["empty_body"].append(source_id) + continue + parent = law_map.get(instrument_id) + if not parent: + report["drops"]["missing_instrument"] += 1 + if len(report["drop_samples"]["missing_instrument"]) < 20: + report["drop_samples"]["missing_instrument"].append( + {"article_id": source_id, "law_id": instrument_id} + ) + continue + meta = parent["metadata"] + art_meta = _parse_meta(_row_get(row, "metadata_json")) + merged_meta = {**meta, **art_meta} + entries.append( + _base_record( + record_type="article", + source_dataset=source_dataset, + source_revision=source_revision, + instrument_id=instrument_id, + instrument_title=parent["instrument_title"], + law_cid=parent["law_cid"], + article_number=article_number, + article_title=article_title, + body=body, + jurisdiction=parent["jurisdiction"], + language=parent["language"] or _row_get(row, "language"), + source_url=_row_get(row, "source_url") or parent["source_url"], + snapshot_date=_snapshot_date(parent["row"], merged_meta, source_meta), + coverage=_coverage_from(parent["row"], merged_meta, articles_empty=False), + license_expr=parent["license"], + collector=_collector(merged_meta, source_dataset), + source_id=source_id, + extra={ + "eli": parent["eli"], + "identifier": parent["identifier"], + "official_identifier": parent["official_identifier"], + "source_type": parent["source_type"], + "country": parent["country"], + "law_status": parent["law_status"], + "parent_law_id": instrument_id, + "article_id": source_id, + **_hierarchy_fields( + article_title, body, article_number, language=parent["language"] + ), + }, + ) + ) + else: + for instrument_id, parent in law_map.items(): + body = parent["body"] + if not body: + report["drops"]["empty_body"] += 1 + if len(report["drop_samples"]["empty_body"]) < 20: + report["drop_samples"]["empty_body"].append(instrument_id) + continue + meta = parent["metadata"] + units = split_structured_units(body, language=parent["language"]) + if units: + report["unit"] = "structured" + for unit in units: + entries.append( + _base_record( + record_type=unit.kind if unit.kind in {"article", "section"} else "article", + source_dataset=source_dataset, + source_revision=source_revision, + instrument_id=instrument_id, + instrument_title=parent["instrument_title"], + law_cid=parent["law_cid"], + article_number=unit.article_number or unit.number, + article_title=unit.heading, + body=unit.body, + jurisdiction=parent["jurisdiction"], + language=parent["language"], + source_url=parent["source_url"], + snapshot_date=_snapshot_date(parent["row"], meta, source_meta), + coverage="structured (headings detected in law body)", + license_expr=parent["license"], + collector=_collector(meta, source_dataset), + source_id=f"{instrument_id}-{unit.kind}-{unit.number}", + extra={ + "eli": parent["eli"], + "identifier": parent["identifier"], + "official_identifier": parent["official_identifier"], + "source_type": parent["source_type"], + "country": parent["country"], + "law_status": parent["law_status"], + "parent_law_id": instrument_id, + "article_id": "", + "hierarchy_kind": unit.kind, + "hierarchy_path": unit.hierarchy_path, + "title_number": unit.title_number, + "chapter_number": unit.chapter_number, + "part_number": unit.part_number, + "section_number": unit.section_number, + "subsections": list(unit.subsections), + }, + ) + ) + continue + entries.append( + _base_record( + record_type="law", + source_dataset=source_dataset, + source_revision=source_revision, + instrument_id=instrument_id, + instrument_title=parent["instrument_title"], + law_cid=parent["law_cid"], + article_number="", + article_title="", + body=body, + jurisdiction=parent["jurisdiction"], + language=parent["language"], + source_url=parent["source_url"], + snapshot_date=_snapshot_date(parent["row"], meta, source_meta), + coverage=_coverage_from( + parent["row"], meta, articles_empty=True, sparse_fallback=sparse_fallback + ), + license_expr=parent["license"], + collector=_collector(meta, source_dataset), + source_id=instrument_id, + extra={ + "eli": parent["eli"], + "identifier": parent["identifier"], + "official_identifier": parent["official_identifier"], + "source_type": parent["source_type"], + "country": parent["country"], + "law_status": parent["law_status"], + "parent_law_id": "", + "article_id": "", + **_hierarchy_fields( + parent["instrument_title"], body, "", language=parent["language"] + ), + }, + ) + ) + + entries.sort( + key=lambda r: ( + r["instrument_id"], + r.get("article_number") or "", + r["source_id"], + ) + ) + n_before = len(entries) + seen: set[str] = set() + deduped: list[dict[str, Any]] = [] + for rec in entries: + cid = rec["entry_cid"] + if cid in seen: + report["drops"]["duplicate_cid"] += 1 + report["drops"]["duplicate_source_kept_first"] += 1 + if len(report["drop_samples"]["duplicate_cid"]) < 20: + report["drop_samples"]["duplicate_cid"].append(rec["source_id"]) + continue + seen.add(cid) + deduped.append(rec) + for i, rec in enumerate(deduped): + rec["document_index"] = i + rec["corpus_index"] = i + + df = pd.DataFrame(deduped) + if not df.empty and df["entry_cid"].duplicated().any(): + raise SchemaError("Duplicate entry_cid remained after dedupe") + report["n_before_dedupe"] = n_before + report["n_out"] = int(len(df)) + report["n_dropped_total"] = ( + report["drops"]["empty_body"] + + report["drops"]["missing_instrument"] + + report["drops"]["duplicate_cid"] + ) + if not df.empty: + report["language_breakdown"] = { + str(k): int(v) for k, v in df["language"].fillna("").value_counts().items() + } + report["record_type_breakdown"] = { + str(k): int(v) for k, v in df["record_type"].value_counts().items() + } + report["jurisdiction_breakdown"] = { + str(k): int(v) for k, v in df["jurisdiction"].fillna("").value_counts().items() + } + snapshot_dates = sorted({str(x) for x in df["snapshot_date"].fillna("") if str(x)}) + report["snapshot_dates"] = snapshot_dates + else: + report["language_breakdown"] = {} + report["record_type_breakdown"] = {} + report["jurisdiction_breakdown"] = {} + report["snapshot_dates"] = [] + + all_article_count_zero = False + if "article_count" in laws.columns and len(laws): + try: + all_article_count_zero = int((laws["article_count"].fillna(0) == 0).sum()) == len(laws) + except Exception: + all_article_count_zero = False + + report["quality_flags"] = { + "articles_table_empty": bool(articles_empty), + "sparse_article_fallback": bool(sparse_fallback), + "article_law_coverage": article_law_coverage, + "all_source_article_counts_zero": all_article_count_zero, + "article_extraction_status_counts": dict(extraction_statuses), + "missing_date": bool("date" in laws.columns and laws["date"].isna().all()) if len(laws) else False, + "missing_date_issued": bool("date_issued" in laws.columns and laws["date_issued"].isna().all()) if len(laws) else False, + "eli_present": bool("eli" in laws.columns and laws["eli"].notna().any()) if len(laws) else False, + "never_invented_legal_text": True, + "empty_bodies_dropped": report["drops"]["empty_body"], + "duplicate_cids_dropped": report["drops"]["duplicate_cid"], + } + from .profiles import majority_language, score_heading_languages + + sample_text = "" + if not df.empty and "body" in df.columns: + sample_text = "\n".join(str(x) for x in df["body"].head(40).tolist()) + if "title" in df.columns: + sample_text = "\n".join(str(x) for x in df["title"].head(40).tolist()) + "\n" + sample_text + heading_langs = score_heading_languages(sample_text) + report["heading_language_counts"] = dict(heading_langs) + report["heading_language_majority"] = majority_language(heading_langs) + report["document_language_majority"] = None + if report.get("language_breakdown"): + report["document_language_majority"] = max( + report["language_breakdown"].items(), key=lambda kv: kv[1] + )[0] + from .verify import verify_normalized_corpus + + report["verification"] = verify_normalized_corpus(df, report) + df.attrs["normalization_report"] = report + return df, report diff --git a/query.py b/query.py new file mode 100644 index 0000000000000000000000000000000000000000..9cd3a1da6f2ac29b2287609ec1bc797fd55c4774 --- /dev/null +++ b/query.py @@ -0,0 +1,204 @@ +#!/usr/bin/env python3 +"""Thin-client query for country-laws IR releases (local dir).""" + +from __future__ import annotations + +import argparse +import json +from collections import defaultdict +from pathlib import Path + +import numpy as np +import pandas as pd + +K1 = 1.2 +B = 0.75 +TITLE_WEIGHT = 5.0 +BODY_WEIGHT = 1.0 +MAX_QUERY_TERMS = 64 + + +def tokenize(text: str) -> list[str]: + import re + import unicodedata + + if not text: + return [] + nfkd = unicodedata.normalize("NFKD", text) + folded = "".join(ch for ch in nfkd if not unicodedata.combining(ch)).lower() + return re.findall(r"[0-9A-Za-z]+", folded) + + +class Release: + def __init__(self, root: Path): + self.root = Path(root) + self.manifest = json.loads((self.root / "manifest.json").read_text(encoding="utf-8")) + + def _read(self, rel: str) -> pd.DataFrame: + path = self.root / rel + if path.is_dir(): + files = sorted(path.glob("*.parquet")) + return pd.concat([pd.read_parquet(f) for f in files], ignore_index=True) if files else pd.DataFrame() + return pd.read_parquet(path) + + def bm25(self, query: str, top_k: int = 10) -> list[dict]: + try: + from .duckdb_store import bm25_search + + return bm25_search(self.root, query, top_k=top_k) + except Exception: + pass + q_terms = tokenize(query)[:MAX_QUERY_TERMS] + if not q_terms: + return [] + shards = pd.read_parquet(self.root / "indexes" / "bm25_keyword_shards.parquet") + needed = set() + for term in q_terms: + hit = shards[(shards["first_key"] <= term) & (shards["last_key"] >= term)] + if hit.empty: + hit = shards + for rel in hit["relative_path"].tolist(): + needed.add(rel) + postings = pd.concat( + [pd.read_parquet(self.root / rel) for rel in sorted(needed)], + ignore_index=True, + ) + postings = postings[postings["term"].isin(q_terms)] + docs = self._read("data/bm25/documents") + avgdl = float(self.manifest["bm25"]["average_document_length"]) or 1.0 + scores: dict[int, float] = defaultdict(float) + for rec in postings.itertuples(index=False): + idf = float(rec.idf) + for di, ttf, btf, dl in zip( + rec.document_indices, rec.title_frequencies, rec.body_frequencies, rec.document_lengths + ): + tf = TITLE_WEIGHT * int(ttf) + BODY_WEIGHT * int(btf) + denom = tf + K1 * (1.0 - B + B * (int(dl) / avgdl)) + if denom: + scores[int(di)] += idf * (tf * (K1 + 1.0)) / denom + ranked = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)[:top_k] + by_idx = docs.set_index("document_index") + out = [] + for di, score in ranked: + row = by_idx.loc[di] + out.append( + { + "document_index": int(di), + "entry_cid": row["entry_cid"], + "title": row["title"], + "record_type": row["record_type"], + "instrument_id": row.get("instrument_id", row.get("law_id", "")), + "law_cid": row.get("law_cid", ""), + "score": float(score), + } + ) + return out + + def vector(self, query: str, top_k: int = 10, candidate_centroids: int = 4, device: str = "cpu") -> list[dict]: + status = (self.manifest.get("vector") or {}).get("status") + if status == "stub": + return [{"error": "vectors are stubbed", "reason": self.manifest["vector"].get("stub_reason")}] + from sentence_transformers import SentenceTransformer + + model = SentenceTransformer(self.manifest["vector"]["model_name"], device=device) + q = model.encode([query], normalize_embeddings=True, convert_to_numpy=True)[0].astype(np.float32) + meta = pd.read_parquet(self.root / "indexes" / "vector_chunks.parquet") + cents = np.stack(meta["centroid"].map(lambda c: np.asarray(c, dtype=np.float32)).to_numpy()) + sims = cents @ q + order = np.argsort(-sims)[: max(1, candidate_centroids)] + shards = meta.iloc[order] + frames = [pd.read_parquet(self.root / rel) for rel in shards["relative_path"].tolist()] + vecs = pd.concat(frames, ignore_index=True) + if "embedding" not in vecs.columns or vecs["embedding"].isna().all(): + return [{"error": "vector shard missing embeddings"}] + emb = np.stack(vecs["embedding"].map(lambda e: np.asarray(e, dtype=np.float32)).to_numpy()) + scores = emb @ q + top = np.argsort(-scores)[:top_k] + out = [] + for i in top: + row = vecs.iloc[int(i)] + out.append( + { + "document_index": int(row["document_index"]), + "entry_cid": row["entry_cid"], + "title": row["title"], + "record_type": row["record_type"], + "instrument_id": row.get("instrument_id", row.get("law_id", "")), + "score": float(scores[int(i)]), + } + ) + return out + + def neighbors(self, node_cid: str, direction: str = "both", limit: int = 25) -> list[dict]: + try: + from .duckdb_store import graph_neighbors + + return graph_neighbors(self.root, node_cid, direction=direction, limit=limit) + except Exception: + pass + dirs = ["incoming", "outgoing"] if direction == "both" else [direction] + hits = [] + for d in dirs: + path = self.root / "data" / "graph" / "adjacency" / d + files = sorted(path.glob("*.parquet")) + for f in files: + df = pd.read_parquet(f) + sub = df[df["node_cid"] == node_cid] + for rec in sub.itertuples(index=False): + for i, neigh in enumerate(rec.neighbor_cids): + hits.append( + { + "direction": d, + "node_cid": node_cid, + "neighbor_cid": neigh, + "edge_type": rec.edge_types[i] if i < len(rec.edge_types) else "", + "score": rec.scores[i] if rec.scores is not None and i < len(rec.scores) else None, + } + ) + hits.sort(key=lambda r: (-(r["score"] or 0), r["neighbor_cid"])) + return hits[:limit] + + +def _print(rows: list[dict]) -> None: + print(json.dumps(rows, indent=2, ensure_ascii=False)) + + +def main(argv: list[str] | None = None) -> int: + ap = argparse.ArgumentParser(description="Query a country-laws IR release") + ap.add_argument("--local-dir", required=True, help="Path to local release root") + sub = ap.add_subparsers(dest="cmd", required=True) + + p_bm = sub.add_parser("bm25") + p_bm.add_argument("query") + p_bm.add_argument("--top-k", type=int, default=10) + + p_vec = sub.add_parser("vector") + p_vec.add_argument("query") + p_vec.add_argument("--top-k", type=int, default=10) + p_vec.add_argument("--candidate-centroids", type=int, default=4) + p_vec.add_argument("--device", default="cuda") + + p_g = sub.add_parser("graph") + g_sub = p_g.add_subparsers(dest="graph_cmd", required=True) + p_n = g_sub.add_parser("neighbors") + p_n.add_argument("node_cid") + p_n.add_argument( + "--direction", + default="both", + choices=["both", "in", "out", "incoming", "outgoing"], + ) + p_n.add_argument("--limit", type=int, default=25) + + args = ap.parse_args(argv) + rel = Release(Path(args.local_dir)) + if args.cmd == "bm25": + _print(rel.bm25(args.query, top_k=args.top_k)) + elif args.cmd == "vector": + _print(rel.vector(args.query, top_k=args.top_k, candidate_centroids=args.candidate_centroids, device=args.device)) + elif args.cmd == "graph" and args.graph_cmd == "neighbors": + _print(rel.neighbors(args.node_cid, direction=args.direction, limit=args.limit)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/reports/normalization.json b/reports/normalization.json new file mode 100644 index 0000000000000000000000000000000000000000..2b9423d9f359b609fc3665ef19e12cbbb6269898 --- /dev/null +++ b/reports/normalization.json @@ -0,0 +1,175 @@ +{ + "source_dataset": "endomorphosis/ipfs_hongkong_laws", + "source_revision": "e12d7058e26d35c3d1fff4cabe6a18a66e8ce3bc", + "laws_sha256": "a318e63b8e47c5c2600497ce2fc3688296b049cbfd9ab68acc2e2b00b6b3a772", + "articles_sha256": "6905c6e49a0b0cdaaad5191fead3950e04aa11f4f8bd4deeadd29fd610c196e8", + "n_laws_in": 1678, + "n_articles_in": 86041, + "unit": "article", + "article_law_coverage": 51.275923718712754, + "sparse_article_fallback": false, + "drops": { + "empty_body": 0, + "missing_instrument": 0, + "duplicate_cid": 426, + "duplicate_source_kept_first": 426 + }, + "drop_samples": { + "empty_body": [], + "missing_instrument": [], + "duplicate_cid": [ + "hk-cap109-en-sch-1-114", + "hk-cap109-en-sch-3-129", + "hk-cap109-zh-hant-sch-1-114", + "hk-cap109-zh-hant-sch-3-129", + "hk-cap112-en-sch-3-1201", + "hk-cap112-en-sch-3-726", + "hk-cap112-zh-hant-sch-1-1199", + "hk-cap112-zh-hant-sch-3-1175", + "hk-cap112-zh-hant-sch-3-1201", + "hk-cap112-zh-hant-sch-3-726", + "hk-cap156-en-sch-1-201", + "hk-cap156-en-sch-1-204", + "hk-cap156-en-sch-10-170", + "hk-cap156-en-sch-11-171", + "hk-cap156-en-sch-12-172", + "hk-cap156-en-sch-13-173", + "hk-cap156-en-sch-14-174", + "hk-cap156-en-sch-15-175", + "hk-cap156-en-sch-16-176", + "hk-cap156-en-sch-17-177" + ] + }, + "language_breakdown": { + "en": 42842, + "zh-Hant": 42773 + }, + "quality_flags": { + "articles_table_empty": false, + "sparse_article_fallback": false, + "article_law_coverage": 51.275923718712754, + "all_source_article_counts_zero": false, + "article_extraction_status_counts": { + "ok": 1586, + "missing": 92 + }, + "missing_date": false, + "missing_date_issued": true, + "eli_present": false, + "never_invented_legal_text": true, + "empty_bodies_dropped": 0, + "duplicate_cids_dropped": 426 + }, + "schema_surprises": [ + "laws.article_count dtype=int32", + "laws.date_issued is entirely null", + "laws.eli non-null=0/1678", + "laws.language values=['en', 'zh-Hant']" + ], + "n_out": 85615, + "never_invented_legal_text": true, + "n_before_dedupe": 86041, + "n_dropped_total": 426, + "record_type_breakdown": { + "article": 85615 + }, + "jurisdiction_breakdown": { + "HK": 85615 + }, + "snapshot_dates": [ + "2026-09-03" + ], + "heading_language_counts": { + "en": 22 + }, + "heading_language_majority": "en", + "document_language_majority": "en", + "verification": { + "schema_version": "country-laws-normalize-verify/v1", + "slug": "", + "admitted": true, + "n_checks": 7, + "n_failed": 0, + "failed_ids": [], + "checks": [ + { + "id": "nonempty_corpus", + "severity": "fail", + "passed": true, + "message": "normalized corpus has rows", + "evidence": { + "n_out": 85615, + "n_dropped": 426 + } + }, + { + "id": "entry_cid_unique", + "severity": "fail", + "passed": true, + "message": "every row has a unique entry_cid", + "evidence": { + "missing": 0, + "empty": 0, + "duplicate": 0 + } + }, + { + "id": "never_invented_legal_text", + "severity": "fail", + "passed": true, + "message": "normalizer did not invent legal text", + "evidence": { + "never_invented_legal_text": true + } + }, + { + "id": "html_residual", + "severity": "fail", + "passed": true, + "message": "HTML tags stripped from legal bodies", + "evidence": { + "n_bodies": 85615, + "n_with_tags": 0, + "fraction": 0.0, + "samples": [] + } + }, + { + "id": "short_bodies", + "severity": "warn", + "passed": true, + "message": "most legal units have usable body length", + "evidence": { + "n_short": 12392, + "n_bodies": 85615, + "fraction": 0.1447409916486597 + } + }, + { + "id": "legal_structure", + "severity": "warn", + "passed": true, + "message": "retrieval units are structured (article, coverage=1.00)", + "evidence": { + "unit": "article", + "structured_rows": 85615, + "coverage": 1.0 + } + }, + { + "id": "heading_language", + "severity": "warn", + "passed": true, + "message": "heading lexicon en vs document language en", + "evidence": { + "document_language": "en", + "heading_language": "en", + "heading_counts": { + "en": 22 + } + } + } + ], + "blocks_graphrag": false + } +} diff --git a/skill/query-country-laws-hf/SKILL.md b/skill/query-country-laws-hf/SKILL.md new file mode 100644 index 0000000000000000000000000000000000000000..c0b2c9f5ef1276059ca735d2d554f270ac614d07 --- /dev/null +++ b/skill/query-country-laws-hf/SKILL.md @@ -0,0 +1,34 @@ +--- +name: query-country-laws-hf +description: Query a local or Hub country-laws-ir GraphRAG release (BM25, vectors, graph neighbors). Research retrieval only — not legal advice. +--- + +# Query country-laws-ir (SkillCenter-style sparse GraphRAG) + +Thin client for `justicedao/ipfs_hongkong_laws_ir` / local release roots that follow +`country-laws-ir-graphrag/v1` (layout family `skillcenter-huggingface-release/v3`). + +**Not legal advice.** Official gazettes prevail. Retrieved hits are context only. + +## Local + +```bash +python scripts/query_country_laws_hf.py --local-dir . bm25 "constitution" --top-k 5 +python scripts/query_country_laws_hf.py --local-dir . vector "money laundering" --top-k 5 +python scripts/query_country_laws_hf.py --local-dir . graph neighbors <entry_cid> +``` + +Or: + +```bash +python -m country_laws_ir query --local-dir /workspace/country-laws-ir/releases/ipfs_hongkong_laws_ir -- bm25 "constitution" +``` + +## Method + +- Primary key `entry_cid` (CIDv1 raw sha2-256). `document_index` is a shard pointer. +- BM25 Okapi k1=1.2 b=0.75, title_weight=5, body_weight=1, FTS5-style tokenizer. +- Vectors `thenlper/gte-small` 384-d, mean-pool, L2, centroid-sorted shards. +- Graph: facets + `BM25_NEIGHBOR_OF` (k=8, score + matched terms) + `ARTICLE_OF`. + +Do not treat retrieval as proof. Do not invent citations.