diff --git a/README.md b/README.md index 7ac8b59869d9865bb60503dbc3bc2f9c50df715c..a6210c369d5c92ce377571e23b86f397f224f40e 100644 --- a/README.md +++ b/README.md @@ -72,14 +72,14 @@ Target Hub id (packaging metadata only): `justicedao/ipfs_peru_laws_ir`. | Field | Value | | --- | --- | -| Laws (corpus units) | 0 | +| Laws (corpus units) | 1735 | | Articles (corpus units) | 14345 | -| Canonical docs | 14345 | -| BM25 terms | 63616 | -| BM25 postings | 1546715 | -| Graph nodes | 20617 | -| Graph edges | 114760 | -| Vectors | 14345 × 384-d `thenlper/gte-small` (partial) | +| Canonical docs | 16080 | +| BM25 terms | 67529 | +| BM25 postings | 2428340 | +| Graph nodes | 23024 | +| Graph edges | 128640 | +| Vectors | 16080 × 384-d `thenlper/gte-small` (embedded) | ## Canonical fields diff --git a/build.py b/build.py index 0e6b82f409b0f85a8460b49d5039733040996490..768973af97da5ea96deef2b5b7bbbc06909d9ebe 100644 --- a/build.py +++ b/build.py @@ -60,8 +60,17 @@ 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( @@ -202,7 +211,11 @@ def build_country( ) ) plan = plan_rebuild( - mode=mode, source_meta=source_meta, prior=prior, force=force + 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}") @@ -234,6 +247,13 @@ 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 @@ -243,6 +263,7 @@ def build_country( 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} " @@ -394,17 +415,29 @@ def reindex_from_gaps( skip_vectors: bool = False, workers: int = 4, mode: str = "auto", + force: bool = False, + all_indexable: bool = False, + device: str = "cuda", ) -> list[dict[str, Any]]: - """Scan Hub gaps and incrementally rebuild stale/missing country IR. + """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: - report = gap_report(workers=workers) - rows = [c for c in report["countries"] if c.get("rebuild")] + 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 = [ @@ -415,33 +448,54 @@ def reindex_from_gaps( if limit is not None: rows = rows[: int(limit)] slugs = [str(r["slug"]) for r in rows] - _log( - f"reindex targets n={len(slugs)} " - f"(from scan rebuild={len(report.get('rebuild') or [])})" + 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(), + } ) - results: list[dict[str, Any]] = [] - for slug in slugs: - _log(f"reindex start {slug}") - try: - results.append( - build_country( - slug, - upload=upload, - mode=mode, - skip_vectors=skip_vectors, - fetch_hub_prior_ir=True, - ) - ) - except Exception as exc: - _log(f"FAILED {slug}: {exc}") - record_progress( - { - "event": "failed", - "country": slug, - "error": str(exc), - "traceback": traceback.format_exc(), - } - ) - results.append({"country": slug, "skipped": False, "error": str(exc)}) - continue - return results + return {"country": slug, "skipped": False, "error": str(exc)} diff --git a/country_laws_ir/__main__.py b/country_laws_ir/__main__.py index 6c290939fff5b2871bb2d70b2198aefee715c946..438bb8d0cca0f061a42ee449d414a2ff2c0383cf 100644 --- a/country_laws_ir/__main__.py +++ b/country_laws_ir/__main__.py @@ -66,8 +66,22 @@ def main(argv: list[str] | None = None) -> int: 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=4) + 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") @@ -149,7 +163,7 @@ def main(argv: list[str] | None = None) -> int: if args.cmd == "reindex": from .build import reindex_from_gaps - cap = None if int(args.max_corpus_rows or 0) <= 0 else int(args.max_corpus_rows) + 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, @@ -158,6 +172,9 @@ def main(argv: list[str] | None = None) -> int: skip_vectors=args.skip_vectors, workers=args.workers, mode=args.mode, + force=args.force, + all_indexable=args.all, + device=args.device, ) print(json.dumps( [ @@ -177,6 +194,65 @@ def main(argv: list[str] | None = None) -> int: 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 diff --git a/country_laws_ir/build.py b/country_laws_ir/build.py index 0e6b82f409b0f85a8460b49d5039733040996490..768973af97da5ea96deef2b5b7bbbc06909d9ebe 100644 --- a/country_laws_ir/build.py +++ b/country_laws_ir/build.py @@ -60,8 +60,17 @@ 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( @@ -202,7 +211,11 @@ def build_country( ) ) plan = plan_rebuild( - mode=mode, source_meta=source_meta, prior=prior, force=force + 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}") @@ -234,6 +247,13 @@ 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 @@ -243,6 +263,7 @@ def build_country( 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} " @@ -394,17 +415,29 @@ def reindex_from_gaps( skip_vectors: bool = False, workers: int = 4, mode: str = "auto", + force: bool = False, + all_indexable: bool = False, + device: str = "cuda", ) -> list[dict[str, Any]]: - """Scan Hub gaps and incrementally rebuild stale/missing country IR. + """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: - report = gap_report(workers=workers) - rows = [c for c in report["countries"] if c.get("rebuild")] + 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 = [ @@ -415,33 +448,54 @@ def reindex_from_gaps( if limit is not None: rows = rows[: int(limit)] slugs = [str(r["slug"]) for r in rows] - _log( - f"reindex targets n={len(slugs)} " - f"(from scan rebuild={len(report.get('rebuild') or [])})" + 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(), + } ) - results: list[dict[str, Any]] = [] - for slug in slugs: - _log(f"reindex start {slug}") - try: - results.append( - build_country( - slug, - upload=upload, - mode=mode, - skip_vectors=skip_vectors, - fetch_hub_prior_ir=True, - ) - ) - except Exception as exc: - _log(f"FAILED {slug}: {exc}") - record_progress( - { - "event": "failed", - "country": slug, - "error": str(exc), - "traceback": traceback.format_exc(), - } - ) - results.append({"country": slug, "skipped": False, "error": str(exc)}) - continue - return results + return {"country": slug, "skipped": False, "error": str(exc)} diff --git a/country_laws_ir/citations.py b/country_laws_ir/citations.py new file mode 100644 index 0000000000000000000000000000000000000000..a73b5c86ca506598373610d200bfc4e381444163 --- /dev/null +++ b/country_laws_ir/citations.py @@ -0,0 +1,147 @@ +"""Official and Bluebook citations for country-law corpus rows. + +Bluebook T2/T10 abbreviations are used only when this table has a row. +Unknown jurisdictions get ``official_citation`` only — never a invented +Bluebook form. Query keys are normalized so ``ORS 1.010`` and +``Or. Rev. Stat. § 1.010`` can hit the same row later. +""" + +from __future__ import annotations + +from dataclasses import dataclass +import re +import unicodedata +from typing import Any + +# slug or country name (lower) -> Bluebook T2/T10 statute abbreviation. +# Empty pinpoint templates are filled with article/section when present. +_BLUEBOOK_STATUTE: dict[str, str] = { + "australia": "Cth", + "canada": "S.C.", + "united kingdom": "U.K.", + "uk": "U.K.", + "united states": "U.S.C.", + "usa": "U.S.C.", + "germany": "BGBl.", + "france": "J.O.", + "malta": "Laws of Malta", + "ireland": "Ir.", + "newzealand": "N.Z.", + "new zealand": "N.Z.", + "southafrica": "S. Afr.", + "south africa": "S. Afr.", + "india": "India", + "japan": "Japan", + "china": "P.R.C.", + "netherlands": "Stb.", + "austria": "BGBl.", + "switzerland": "AS", + "sweden": "SFS", + "norway": "Norsk Lovtidend", + "denmark": "Lovtidende", + "finland": "Finlex", + "eu": "O.J.", +} + + +@dataclass(frozen=True) +class Citation: + official_citation: str + bluebook_citation: str + cite_key: str + citation_status: str # bluebook | official_only | unknown + pinpoint: str + + +def normalize_cite_key(value: str) -> str: + if not value: + return "" + text = unicodedata.normalize("NFKC", value).lower() + text = text.replace("§", " s ") + text = text.replace("¶", " ") + text = re.sub(r"\bart(?:icle|\.)?\b", "art", text) + text = re.sub(r"\bsec(?:tion|\.)?\b", "s", text) + text = re.sub(r"[^a-z0-9]+", " ", text) + return re.sub(r"\s+", " ", text).strip() + + +def _pinpoint(article_number: str, section_number: str, record_type: str) -> str: + if record_type == "section" and section_number: + return f"§ {section_number}" + if article_number: + return f"art. {article_number}" + if section_number: + return f"§ {section_number}" + return "" + + +def _bluebook_abbrev(jurisdiction: str, country: str, slug: str = "") -> str: + for key in (slug, country, jurisdiction): + hit = _BLUEBOOK_STATUTE.get(str(key or "").strip().lower().replace("_", " ")) + if hit: + return hit + return "" + + +def assign_citation( + *, + eli: str = "", + official_identifier: str = "", + identifier: str = "", + instrument_title: str = "", + article_number: str = "", + section_number: str = "", + record_type: str = "law", + jurisdiction: str = "", + country: str = "", + slug: str = "", + year: str = "", +) -> Citation: + pinpoint = _pinpoint(article_number, section_number, record_type) + official = ( + (eli or "").strip() + or (official_identifier or "").strip() + or (identifier or "").strip() + or (instrument_title or "").strip() + ) + if official and pinpoint and pinpoint.lower() not in official.lower(): + official_cite = f"{official}, {pinpoint}" + else: + official_cite = official + + abbrev = _bluebook_abbrev(jurisdiction, country, slug) + bluebook = "" + if abbrev and official: + if pinpoint: + if year: + bluebook = f"{abbrev} {pinpoint} ({year})" + else: + bluebook = f"{abbrev} {pinpoint}" + else: + bluebook = f"{abbrev} {official}" if official != abbrev else abbrev + + if bluebook: + status = "bluebook" + elif official_cite: + status = "official_only" + else: + status = "unknown" + + key_src = bluebook or official_cite + return Citation( + official_citation=official_cite, + bluebook_citation=bluebook, + cite_key=normalize_cite_key(key_src), + citation_status=status, + pinpoint=pinpoint, + ) + + +def citation_fields(cite: Citation) -> dict[str, Any]: + return { + "official_citation": cite.official_citation, + "bluebook_citation": cite.bluebook_citation, + "cite_key": cite.cite_key, + "citation_status": cite.citation_status, + "pinpoint": cite.pinpoint, + } diff --git a/country_laws_ir/duckdb_store.py b/country_laws_ir/duckdb_store.py index 743473eea8b69f71eb222568bcadf0549160db49..84cd52b7e05f8b35192c86ac93cf8c680a656795 100644 --- a/country_laws_ir/duckdb_store.py +++ b/country_laws_ir/duckdb_store.py @@ -151,6 +151,73 @@ def bm25_search(root: Path, query: str, top_k: int = 10) -> list[dict[str, Any]] con.close() +def cite_search( + root: Path, + citation: str, + *, + cite_format: str = "any", + limit: int = 25, +) -> list[dict[str, Any]]: + """Look up corpus rows by Bluebook, official cite, or normalized cite_key.""" + from .citations import normalize_cite_key + + needle = (citation or "").strip() + if not needle: + return [] + key = normalize_cite_key(needle) + 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 "corpus" not in tables: + raise DuckDBStoreError("release is missing corpus parquet shards") + cols = [ + r[1] + for r in con.execute( + "SELECT table_schema, column_name FROM information_schema.columns " + "WHERE table_schema = 'main' AND table_name = 'corpus'" + ).fetchall() + ] + wanted = [ + "entry_cid", + "record_type", + "title", + "instrument_title", + "article_number", + "official_citation", + "bluebook_citation", + "cite_key", + "citation_status", + "source_url", + ] + select = ", ".join(c for c in wanted if c in cols) or "*" + clauses = [] + params: list[Any] = [] + fmt = (cite_format or "any").strip().lower() + if fmt in {"any", "bluebook"} and "bluebook_citation" in cols: + clauses.append("lower(coalesce(bluebook_citation, '')) = lower(?)") + params.append(needle) + if fmt in {"any", "official"} and "official_citation" in cols: + clauses.append("lower(coalesce(official_citation, '')) = lower(?)") + params.append(needle) + if "cite_key" in cols and key: + clauses.append("cite_key = ?") + params.append(key) + if not clauses: + return [] + sql = f"SELECT {select} FROM corpus WHERE {' OR '.join(clauses)} LIMIT ?" + params.append(int(limit)) + rows = con.execute(sql, params).fetchall() + names = [c for c in wanted if c in cols] if select != "*" else list(cols) + return [dict(zip(names, row)) for row in rows] + finally: + con.close() + + def graph_neighbors( root: Path, node_cid: str, diff --git a/country_laws_ir/incremental.py b/country_laws_ir/incremental.py index 9d50697c25456b2057cd4d86403277bc86d43bc0..870039d76530cefabb9284ebd6322289345b1c06 100644 --- a/country_laws_ir/incremental.py +++ b/country_laws_ir/incremental.py @@ -234,6 +234,7 @@ def plan_rebuild( 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) @@ -280,7 +281,7 @@ def plan_rebuild( or ((prior.manifest.get("incremental") or {}).get("vectors") or {}).get("status") or "" ).strip().lower() - stub_vectors = prior_vector_status in { + stub_vectors = rebuild_stub_vectors and prior_vector_status in { "stub", "stub_missing_encoder", "incomplete", diff --git a/country_laws_ir/normalize.py b/country_laws_ir/normalize.py index d518f83f1b2fe701b6c1fc5f79335bc6c760a414..50262d25f90dd4e84427bc9ea2d6a8c8901970ba 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,8 +12,6 @@ from __future__ import annotations import json import os -import re -import unicodedata from collections import Counter from pathlib import Path from typing import Any @@ -25,8 +24,8 @@ 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", @@ -48,9 +47,7 @@ def _empty_articles() -> pd.DataFrame: 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: @@ -285,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): @@ -373,6 +399,34 @@ def _base_record( } if extra: rec.update(extra) + from .citations import assign_citation, citation_fields + + slug = "" + if source_dataset.startswith("endomorphosis/ipfs_") and source_dataset.endswith("_laws"): + slug = source_dataset.split("ipfs_", 1)[1].removesuffix("_laws") + year = "" + if snapshot_date and len(snapshot_date) >= 4 and snapshot_date[:4].isdigit(): + year = snapshot_date[:4] + extra = extra or {} + rec.update( + citation_fields( + assign_citation( + eli=str(rec.get("eli") or extra.get("eli") or ""), + official_identifier=str( + rec.get("official_identifier") or extra.get("official_identifier") or "" + ), + identifier=str(rec.get("identifier") or extra.get("identifier") or ""), + instrument_title=instrument_title, + article_number=article_number, + section_number=str(extra.get("section_number") or ""), + record_type=record_type, + jurisdiction=jurisdiction, + country=str(extra.get("country") or ""), + slug=slug, + year=year, + ) + ) + ) rec["entry_cid"] = _entry_cid(rec) rec["title_length"] = len(title_for_bm25) rec["body_length"] = len(body) @@ -433,11 +487,62 @@ def build_corpus( entries: list[dict[str, Any]] = [] + def _append_law_row(instrument_id: str, parent: dict[str, Any]) -> None: + 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) + return + meta = parent["metadata"] + 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=articles_empty, + 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"] + ), + }, + ) + ) + if sparse_fallback: report["schema_surprises"].append( f"article coverage {article_law_coverage:.4f} < 0.10 of laws; falling back to law-level units" ) + for instrument_id, parent in law_map.items(): + _append_law_row(instrument_id, parent) + if use_articles: for _, row in articles.iterrows(): source_id = _row_get(row, "id") @@ -489,6 +594,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"] + ), }, ) ) @@ -496,44 +604,50 @@ def build_corpus( 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"] - 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": "", - }, - ) - ) + 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), + }, + ) + ) entries.sort( key=lambda r: ( @@ -564,6 +678,20 @@ def build_corpus( raise SchemaError("Duplicate entry_cid remained after dedupe") report["n_before_dedupe"] = n_before report["n_out"] = int(len(df)) + if not df.empty and "record_type" in df.columns: + n_law_rows = int((df["record_type"] == "law").sum()) + n_child_rows = int(df["record_type"].isin(["article", "section"]).sum()) + report["n_law_rows"] = n_law_rows + report["n_child_rows"] = n_child_rows + report["n_instruments"] = int(df["instrument_id"].nunique()) if "instrument_id" in df.columns else n_law_rows + if n_law_rows and n_child_rows: + report["unit"] = ( + "law+structured" if report.get("unit") == "structured" else "law+article" + ) + elif n_law_rows: + report["unit"] = "law" + elif n_child_rows: + report["unit"] = "article" report["n_dropped_total"] = ( report["drops"]["empty_body"] + report["drops"]["missing_instrument"] @@ -607,5 +735,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/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 9cd3a1da6f2ac29b2287609ec1bc797fd55c4774..d1f4db567a8944a31bc19a28c6fb6b78aed632f8 100644 --- a/country_laws_ir/query.py +++ b/country_laws_ir/query.py @@ -158,6 +158,11 @@ class Release: hits.sort(key=lambda r: (-(r["score"] or 0), r["neighbor_cid"])) return hits[:limit] + def cite(self, citation: str, cite_format: str = "any", limit: int = 25) -> list[dict]: + from .duckdb_store import cite_search + + return cite_search(self.root, citation, cite_format=cite_format, limit=limit) + def _print(rows: list[dict]) -> None: print(json.dumps(rows, indent=2, ensure_ascii=False)) @@ -189,6 +194,16 @@ def main(argv: list[str] | None = None) -> int: ) p_n.add_argument("--limit", type=int, default=25) + p_cite = sub.add_parser("cite") + p_cite.add_argument("citation") + p_cite.add_argument( + "--format", + dest="cite_format", + default="any", + choices=["any", "bluebook", "official"], + ) + p_cite.add_argument("--limit", type=int, default=25) + args = ap.parse_args(argv) rel = Release(Path(args.local_dir)) if args.cmd == "bm25": @@ -197,6 +212,8 @@ def main(argv: list[str] | None = None) -> int: _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)) + elif args.cmd == "cite": + _print(rel.cite(args.citation, cite_format=args.cite_format, limit=args.limit)) return 0 diff --git a/country_laws_ir/sparse.py b/country_laws_ir/sparse.py index 5c691b4a91403e46ca842b2a62f76f16f4231fac..5ed793543ef74b1c48e313ee29cada56fd2aface 100644 --- a/country_laws_ir/sparse.py +++ b/country_laws_ir/sparse.py @@ -31,10 +31,18 @@ def corpus_to_bm25_rows(corpus: pd.DataFrame) -> list[dict[str, Any]]: """ 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 "") - body = str(getattr(rec, "body", "") or "") + 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( 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/vectors.py b/country_laws_ir/vectors.py index 31376d982f8d70c0c5e5c2a52192614c84f0cea8..5651e0f0e052dabffed783715a5b3b4c396a7b5e 100644 --- a/country_laws_ir/vectors.py +++ b/country_laws_ir/vectors.py @@ -130,13 +130,6 @@ def encode_corpus( configure_hf() device, _fallback = select_device(device) - 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"), - ) texts = [] for rec in corpus.itertuples(index=False): title = getattr(rec, "title", None) or getattr(rec, "instrument_title", "") or "" @@ -148,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 @@ -165,64 +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, - revision=MODEL_REVISION, - device=device, - ) + ) / "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.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, + 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: diff --git a/country_laws_ir/verify.py b/country_laws_ir/verify.py new file mode 100644 index 0000000000000000000000000000000000000000..e92d5a3e0dbfbe67950a89545a2d432339847d80 --- /dev/null +++ b/country_laws_ir/verify.py @@ -0,0 +1,308 @@ +"""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_parent_laws(corpus: pd.DataFrame, report: dict[str, Any]) -> Check: + """Fail if source had instruments but GraphRAG corpus has no law rows.""" + n_in = int(report.get("n_laws_in") or 0) + n_law_rows = 0 + if corpus is not None and not corpus.empty and "record_type" in corpus.columns: + n_law_rows = int((corpus["record_type"] == "law").sum()) + n_law_rows = int(report.get("n_law_rows") or n_law_rows) + if n_in > 0 and n_law_rows == 0: + return Check( + id="parent_laws", + severity="fail", + passed=False, + message=( + f"source has {n_in} laws but corpus has 0 law rows " + "(articles were indexed without parent instruments)" + ), + evidence={"n_laws_in": n_in, "n_law_rows": n_law_rows}, + ) + return Check( + id="parent_laws", + severity="warn", + passed=True, + message=f"parent instruments present ({n_law_rows} law rows from {n_in} source laws)", + evidence={"n_laws_in": n_in, "n_law_rows": n_law_rows}, + ) + + +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", "law+article", "law+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_parent_laws(corpus, report), + 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 d3c5774ae02225ff2e34717e31556e7592a12205..d96adad2976220b1e2279f3d4d6ff47dbde89c60 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:d5b1b2c049eee968b5e6f9d8f6ad9e08ff5486d95979d38bbc85cfd4c3d8415a -size 501263 +oid sha256:ffebeddf05da3e782aad210b042a5b1dec6092afb33fa7fdb5bfd957f1c52996 +size 513358 diff --git a/data/bm25/documents/part-000001.parquet b/data/bm25/documents/part-000001.parquet index d19014eaad03d0d4399c1aa109117e740c710b94..f48c6cd1a10c081bbd0672cb91975620fd6c3937 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:a3b9f3b04c80ca3c6b50747cc9c8a48237373e1a48b3467d8f4be2c07d9d5835 -size 484287 +oid sha256:1c0c76d50334c876b59d3e635a706e3bffb61dca83d633bd308527c44924980c +size 504395 diff --git a/data/bm25/documents/part-000002.parquet b/data/bm25/documents/part-000002.parquet index 8755652f7a6d92df7a08463ed3d9ecbbfa88e4c2..f9eceea8b0903b3d29022ac4dc4915ce61ae9251 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:29208abd1e55fa3d9128634f5b3abdb76eab6e04622d7f22d49a1161ec14388e -size 463293 +oid sha256:ab034f772d3f23427c662b9463a226d54173fb83386740842c35a9f838a4927c +size 489782 diff --git a/data/bm25/documents/part-000003.parquet b/data/bm25/documents/part-000003.parquet index eb97a863f25aed9337f7ee28678bf19d4f105f01..3961fd463a1258327e6ddb6a28514f5b8aac168d 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:b62303b83f19ddc1d55f321ce42f09caa27539cb7d4724cb245d89231e21e2be -size 246417 +oid sha256:6911cd2bb6f7c2f3f7d35cb94cca63e5e68b4c88c3816b7c3873ebac459705a6 +size 457724 diff --git a/data/bm25/postings/part-000000.parquet b/data/bm25/postings/part-000000.parquet index 165354bd7a5c8d26c9be012bc64756bbdf7dec04..264b7ae17f6f4cd174131635ceb6251efa768a50 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:494600cc82f1b3d6dbfaa05b1f7f867a90005f2b6b958ca00b767e3c62f1585d -size 106349 +oid sha256:4270c6d7617221b9dd6a401f1733fa801092f282948ae04dcd513f256569e21d +size 92819 diff --git a/data/bm25/postings/part-000001.parquet b/data/bm25/postings/part-000001.parquet index fe455b54623785612098fad00c428e681ce46dcd..8c87161795126dc1c81456cb792d6b69673e4f6e 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:93628889d2fb65f24a9c48e47d622a498c8d145667187fbe75391c3266ec4fef -size 105720 +oid sha256:70812cbac3868dd34ffc0dd255d2a7170933b41c6f734641448598c80b3be4f2 +size 162511 diff --git a/data/bm25/postings/part-000002.parquet b/data/bm25/postings/part-000002.parquet index 1e8f25854ff68bef280b88b6ffc2ccae0ae70580..be2109e8d16eaa95a05b5d0d30c0c8846819bde3 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:686a1705a215dfdaedc9ea304ba69c436db3160bd65ef735a78a7558ef87a4e3 -size 121059 +oid sha256:8624d2f9b9abb3fbf22a9eb4115af00e30c8249c9f54c068742ba724d1ec14bc +size 120821 diff --git a/data/bm25/postings/part-000003.parquet b/data/bm25/postings/part-000003.parquet index cf3f7769f347d26c0951232ef3b4b8b349e899ab..1af68612d07ca1ca4e1e29205d89ebfa6c679bf3 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:a932b74a5b07f429ed5aa4915ae27c56a0946c2e4e100427a23b02e4168894d9 -size 45415 +oid sha256:a6f922c703ba2deb068ea24bc7252421c2e0b436e2471efe6cd7dc41567363eb +size 153968 diff --git a/data/bm25/postings/part-000004.parquet b/data/bm25/postings/part-000004.parquet index fce5faf5d21d1ea22d5039153627a89e06d68151..6c9de472db085d5724b49aa89337781a2fa88ba5 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:c58bcd1632128ea4cf483b95aa9be88bb1327550ffe4be405c76362779bf38a8 -size 112621 +oid sha256:e022b6209ffc4f514a85aa247e9d7e3dd7cfbdb4344b70b9b98475be3e1b1e34 +size 141594 diff --git a/data/bm25/postings/part-000005.parquet b/data/bm25/postings/part-000005.parquet index 34e7ed456edecc0d37f3e88b6ba69225c914d983..8f0acd34c64eaeedbea5d37cd0fddcc6665d43fd 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:e006962a8e9fbeb3f518aba118ea33eb27a099ac8c6e9cbd249a6da2bdd58ce7 -size 133183 +oid sha256:7ceec0cd4542b8984385ec5e5fbc7154c18eaee344815afb11c78fa243aa8ee6 +size 142728 diff --git a/data/bm25/postings/part-000006.parquet b/data/bm25/postings/part-000006.parquet index 53865ac86bc0e2113cb45b79a9f0e64849589448..0d2ab6c3cfdb3de0ac1194ce4bc4c1c3365cfe41 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:b61c6477341715bbad747a60c872b3e2c32c7aa9a54fa800a9b8cdf0f280f2ab -size 320649 +oid sha256:d76a151c18c7a2de870f9e893395dc44db631aa95571a8c499eadda5f9fd3ce4 +size 128555 diff --git a/data/bm25/postings/part-000007.parquet b/data/bm25/postings/part-000007.parquet index 9e2d8cd5acc94dbb32645083fd0caafbc4a24174..dc7802a136ec95a539c39237e3d9f09f092267bf 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:381f3b2648d8e4f34d7b1b62e6517c1cc30cb283e1b48a4a01667287c442d779 -size 455025 +oid sha256:bd4c22df4f2312c06a32259da6a0c217d2604104b3045c42411fcaaa4800bdc3 +size 432728 diff --git a/data/bm25/postings/part-000008.parquet b/data/bm25/postings/part-000008.parquet index e3b464593ac636b945fa411d1f0d9153d9e59c40..60ffadac03a1b70f2a99254da0bb91614708d49c 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:95bbfdcb66521a0da27a8ec6869b3d9ac6e42d529ede55bde3fb17cd8173fb48 -size 597690 +oid sha256:d326b0a70c252ac257a5a426ecf9125305c5b28ba17527ffb919dd5999e7185e +size 617863 diff --git a/data/bm25/postings/part-000009.parquet b/data/bm25/postings/part-000009.parquet index bb8fbb5fb1a00dc25ecf6b85c5161f6aa821bf5f..729595bbe8315d9f4c2330518fb03ec5e555a7bb 100644 --- a/data/bm25/postings/part-000009.parquet +++ b/data/bm25/postings/part-000009.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:5c7106a0661c1253fd550634e28a7515220e42520b7ce4c1b9513ae3bdd993dc -size 693372 +oid sha256:dc3b66602773add98b70ee3fe8e09e482bc8a4d1a9a0355b18d52f9a9212b20d +size 834589 diff --git a/data/bm25/postings/part-000010.parquet b/data/bm25/postings/part-000010.parquet index fe9e3a7f2f6c64f00f8c0d0e99bc4d09672e47dd..f7fe2a7c1e5ca8d15792252d2fe36f09c8509555 100644 --- a/data/bm25/postings/part-000010.parquet +++ b/data/bm25/postings/part-000010.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:389e704a2013ce9bbc7ca2c846a5c934cc362edb90e97b16063583e5a3989da8 -size 408149 +oid sha256:7743a2dbaa0893c7d311482d87e42e5f64c98a9bf987b9e5450600a08dfc6121 +size 956886 diff --git a/data/bm25/postings/part-000011.parquet b/data/bm25/postings/part-000011.parquet index 70d6520be5a5b2b0f9f9803f7c73fdfd6b9a8e9b..7b309d3c35ff32bc80c22bd751818b7f4d967ab6 100644 --- a/data/bm25/postings/part-000011.parquet +++ b/data/bm25/postings/part-000011.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:ab86bc6ddf48c8072a3cec33b6a3a2254c4c5bf79f20eae54134a97685ec38d2 -size 565290 +oid sha256:e47751997de26359e940299858ad19dbb7b0bb3e600f9795fff2291f61d52419 +size 561025 diff --git a/data/bm25/postings/part-000012.parquet b/data/bm25/postings/part-000012.parquet index 41f326bfad4079ef48e586d3278a01169a5e51a6..00eae7c25493c319f2d546ba83b2a9d57540dee4 100644 --- a/data/bm25/postings/part-000012.parquet +++ b/data/bm25/postings/part-000012.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:1fb37a311decd8c61641b5fe6d5869705242dc206ac3505762f82ebb3e899db1 -size 622313 +oid sha256:a4efe955030668fee1ed26db1545ee1c1de919a61c8e1e72fe86620233d87610 +size 776840 diff --git a/data/bm25/postings/part-000013.parquet b/data/bm25/postings/part-000013.parquet index e390bf0979f2645424c19553f9380ac301020b89..d730247d7568de676949e93457ca360ef7f312e9 100644 --- a/data/bm25/postings/part-000013.parquet +++ b/data/bm25/postings/part-000013.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:cdc9ceb0dab793d1776d907e2c6cfd07c3d4ad5834b11ad9ff5fc7f5f8d144f0 -size 590569 +oid sha256:b5937727b617f773f4ca837c96a3c2a061085f4e58d3455505b1d7a8a84f18fb +size 851922 diff --git a/data/bm25/postings/part-000014.parquet b/data/bm25/postings/part-000014.parquet index 571ffc4d3c6fdb4f794d64658584b9f52f3d9e4c..867c8058dd4218120757ff633e89e25baa336aaa 100644 --- a/data/bm25/postings/part-000014.parquet +++ b/data/bm25/postings/part-000014.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:3c311aefa3fc49b8c0e3b99e0ff38494f498b83d19e2c652492400083592bf11 -size 571075 +oid sha256:8d43a859923da0c18f1b356a7014ce3391817264c453212c8285c14226e5d07e +size 888867 diff --git a/data/bm25/postings/part-000015.parquet b/data/bm25/postings/part-000015.parquet index fbc827370a2e03d8004a15612971d545a2968dff..0620061b85d7a09d65de74c18d1d7bc97bfb1ac3 100644 --- a/data/bm25/postings/part-000015.parquet +++ b/data/bm25/postings/part-000015.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:a1f18da19ec633e11d78032996bbe2439e83ce1639b3c117af72d51473e44dca -size 261877 +oid sha256:e7cb739836d62a19eb3326125e4d6695048fbb6c31e153851f506ae2787610d0 +size 763588 diff --git a/data/bm25/postings/part-000016.parquet b/data/bm25/postings/part-000016.parquet new file mode 100644 index 0000000000000000000000000000000000000000..f97f7b0f7cffcd94fd8cc4643ba7106f27006962 --- /dev/null +++ b/data/bm25/postings/part-000016.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2cbe4eaad81a2ea360170596bca7a5cc793512f4c68fdf9fc21209c8e455b535 +size 334563 diff --git a/data/corpus/part-000000.parquet b/data/corpus/part-000000.parquet index 36339d98ad91a8fc657844b3f09809c73c08ec00..ffaf8198a4d025555fc38cb18adf5bdcae845ca0 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:eb7d8c554113cbc0560f9e2d98d670c1d440b5553b6a0937df8f9c44888b39a4 -size 1951466 +oid sha256:ab974a2845f50a753e8cf522d670bc8fc350882a594e439a51fee1a882760c61 +size 2114859 diff --git a/data/corpus/part-000001.parquet b/data/corpus/part-000001.parquet index 52a78ec95f841ddd6ca3e03d935a584568f25f80..08382a3917f47277bbfef62889d67aa325f4cb99 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:c5fa74a0b0f879dfda67f783f63817a96be691be3e68640d68b56af4ebc812dd -size 1727243 +oid sha256:43beb750de02d16013a5063764a8b26a302cefa281a9c372e8144bcaa4cf9169 +size 2017293 diff --git a/data/corpus/part-000002.parquet b/data/corpus/part-000002.parquet index 0e1cf70988fa1f480cad81701a2e348a6e694357..f5052e384c5dadb69d3f5cb777fc8ff7fa974e22 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:f6ecd95e6b87d219f99332a05226893f6dd2dca41f01e99f5bfbde2ef01acb54 -size 1751152 +oid sha256:a44db5e43e50f93b863bb836f868802d572a0da122027732a908a70d00c8bc2d +size 1898388 diff --git a/data/corpus/part-000003.parquet b/data/corpus/part-000003.parquet index 4a0be99123cfde9cf697b7cce5fe54e70d9a0d99..cd46958da2ce350314f8c1436afb1cea0b88f42d 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:f62cf8c89fef6c76f749a8d29f61f01f66527f3db5a82743bb61fdc601fd1fcf -size 1079395 +oid sha256:79222f0246b060b5ed007d94e722636bf2460cec405b29854e9b24a4b5995ab4 +size 1966041 diff --git a/data/graph/adjacency/in/part-000000.parquet b/data/graph/adjacency/in/part-000000.parquet index aa92cf7dbaff9e4c5cf2fda7e94e339436344a5d..28a285651ed46fd01aecac8f07d947c64766b0f3 100644 --- a/data/graph/adjacency/in/part-000000.parquet +++ b/data/graph/adjacency/in/part-000000.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8a86cbe58fa2eb58cd345c7ca8eaf6e219fbea34b61c1a378e76b4c49dde8a6c -size 563014 +oid sha256:f0f4028fc01a25a8e6fe9d5431b56a298575f78127d7ac0536188025a987b687 +size 577124 diff --git a/data/graph/adjacency/in/part-000001.parquet b/data/graph/adjacency/in/part-000001.parquet index 02634d793a576234f283f50f225cb91edea3da55..d7c31de2ad3a7dfbbc8e1e7129c017dc1d06e9f2 100644 --- a/data/graph/adjacency/in/part-000001.parquet +++ b/data/graph/adjacency/in/part-000001.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:554b9387ed59a575011de1b9eb3e35a15390f5708afd244897a50b9499ea1c10 -size 583151 +oid sha256:5b0f43d85d9fbb4708737589f4d3461843be50751a5a4a4e48f19292a5805636 +size 584309 diff --git a/data/graph/adjacency/in/part-000002.parquet b/data/graph/adjacency/in/part-000002.parquet index 64116f6d1d8a38564092ec88ff8c7a97e6539b86..84b61d750e08bbab3b1b96c466dd11913d774782 100644 --- a/data/graph/adjacency/in/part-000002.parquet +++ b/data/graph/adjacency/in/part-000002.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:6b60688fe5a41b61b0fdcd8c63ee1ac614375a39bbb5e3bfa71a26b6388990fa -size 563252 +oid sha256:0799da0d7b773772d5f88a5385ff8f0c586dc8541100d974ed14bf474e47c00c +size 579557 diff --git a/data/graph/adjacency/in/part-000003.parquet b/data/graph/adjacency/in/part-000003.parquet index ca1c85068ffe693685fbc2d3deb26d2c26946ca7..d533ac70d5349cebd265271e5bc409483eaa7068 100644 --- a/data/graph/adjacency/in/part-000003.parquet +++ b/data/graph/adjacency/in/part-000003.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:62c7728bd631ca8037b287795b17fe98bd059750a4bc993f959e90c93c1f8e35 -size 410002 +oid sha256:40f0a161ef976d21ec007a2a56232a9f66e1def32c2df0d736dfa9f4abad75c0 +size 322534 diff --git a/data/graph/adjacency/in/part-000004.parquet b/data/graph/adjacency/in/part-000004.parquet index 3a25617a265f534cc4345554a28ebad7a7a8f52a..77cbed093268d6204ab44a5513dfb32abe669baa 100644 --- a/data/graph/adjacency/in/part-000004.parquet +++ b/data/graph/adjacency/in/part-000004.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:e9877fb824e3748cb95ea6bea417900335b6377f786d0f93134dd6a09062c30b -size 583330 +oid sha256:a1551f01d7574dd442effe3e1f1df8d71a6863f4410dee17faa934f78e1281d8 +size 584279 diff --git a/data/graph/adjacency/in/part-000005.parquet b/data/graph/adjacency/in/part-000005.parquet index 2c10c877b12f5cf3e7f5584db570ded356952b85..eb05e75746973eeb87d3802f917e256e003c49d4 100644 --- a/data/graph/adjacency/in/part-000005.parquet +++ b/data/graph/adjacency/in/part-000005.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:85539b8d818514092fa67839ad8e6275589b888698a5fcf2360a68bf6c19857c -size 563382 +oid sha256:09e76002403a7963fcb9c2fc034878b13e4393505f14ce99017842bafa4909e9 +size 580199 diff --git a/data/graph/adjacency/in/part-000006.parquet b/data/graph/adjacency/in/part-000006.parquet index eaba392f68b230b82748f0b03875291cb6bc8045..12eab2388b43ea7005ba264aa05496ce87485865 100644 --- a/data/graph/adjacency/in/part-000006.parquet +++ b/data/graph/adjacency/in/part-000006.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:3cf4c06829f023498f3ab3a3b1a6dcb06974b03c1e1d545ea980fe8169e02dca -size 574601 +oid sha256:9e2daf8b3a33664c27899421285a78f0c7972ab4247c067f04836aee8af6df99 +size 593352 diff --git a/data/graph/adjacency/in/part-000007.parquet b/data/graph/adjacency/in/part-000007.parquet index a15d57a2b813f2286c09e904c6260658f961d7e8..17080277a2e12df6dae802ed6f582924a65f2d26 100644 --- a/data/graph/adjacency/in/part-000007.parquet +++ b/data/graph/adjacency/in/part-000007.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:5a78e4bef1132fe838f24db475fbb7f9cad2564bdf3cd3fafd4bda854bbe1b05 -size 570762 +oid sha256:6b923a47549c142b50351b41e291cef2343128a7063ab840c6cf3e60b751a792 +size 595719 diff --git a/data/graph/adjacency/in/part-000008.parquet b/data/graph/adjacency/in/part-000008.parquet index ac6b08e0d7615d2850a8be620045f40693e45085..23d1c924e2399d3a23824f1816b2fe1a259ba5a7 100644 --- a/data/graph/adjacency/in/part-000008.parquet +++ b/data/graph/adjacency/in/part-000008.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:ace8971285550b720254363b05249b673675c9f897d6d5e7a497f30eace4792a -size 398881 +oid sha256:e7587ee1b1ca7e1a3baad04f8e5a8b5e3e2046deb5a79b30efe3f2e53b98190b +size 589095 diff --git a/data/graph/adjacency/in/part-000009.parquet b/data/graph/adjacency/in/part-000009.parquet index 0fbf871fa7e8e881e15b51cc3ac1fdd68c5a69c2..6adad4d074da6bb85c97a03e558d67dfea6876a8 100644 --- a/data/graph/adjacency/in/part-000009.parquet +++ b/data/graph/adjacency/in/part-000009.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:550483bb874d9b1b4a1a0dfef2279c2d46bb1e70d8ff73f545c47eb9fac890b3 -size 583119 +oid sha256:9f679a37b5dcab4ac024c75a1d531fa344b9c3c62c74b8c1f6d07ab0189c2a3d +size 520675 diff --git a/data/graph/adjacency/in/part-000010.parquet b/data/graph/adjacency/in/part-000010.parquet index 8a66d0db3e850cf14e8a1657f5a1b5c2f526f902..b59779bafbfe3746fdeee49250b4c2359db54748 100644 --- a/data/graph/adjacency/in/part-000010.parquet +++ b/data/graph/adjacency/in/part-000010.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:d945f64abd04cd60a2ee1586ae33e25c42dc733b9c617e4b26ba03e6775dbb2d -size 561848 +oid sha256:367dec54f2150f951b839181c7e6a6ca4687c98dc3577880bf0f4a2dba161fbe +size 583911 diff --git a/data/graph/adjacency/in/part-000011.parquet b/data/graph/adjacency/in/part-000011.parquet index 7dfb3a20a25ff907d44590f45350d495661a3d75..62859582a05da1715af347418d336d369962c585 100644 --- a/data/graph/adjacency/in/part-000011.parquet +++ b/data/graph/adjacency/in/part-000011.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:6f7ce1cb226add3506f51870ecf1e6c3217f41e52796158fe6bfabd862b805d7 -size 566480 +oid sha256:c3f8ec0775f051a61608e7161a02301e6a4572ec79954b6dac45266079baa1e5 +size 580851 diff --git a/data/graph/adjacency/in/part-000012.parquet b/data/graph/adjacency/in/part-000012.parquet index e20a7351c088978655af19a0291df37dc0f5c9a7..26abb18b5015e4b5a2a8fb77db92d9a1bc92e382 100644 --- a/data/graph/adjacency/in/part-000012.parquet +++ b/data/graph/adjacency/in/part-000012.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8884b5571a6209d19e5e1abb094e54feb8312d0adea6d31c3e49f0d3392ead02 -size 462629 +oid sha256:186046c27e15d65182770153724bd183b287ef760a0b33aec6183728563d9ace +size 571347 diff --git a/data/graph/adjacency/in/part-000013.parquet b/data/graph/adjacency/in/part-000013.parquet index 79ad2806d45515b4fb2593563a03def7a52b9030..c3cdd0b425430a889080b1e438a8ff9dee2922fd 100644 --- a/data/graph/adjacency/in/part-000013.parquet +++ b/data/graph/adjacency/in/part-000013.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:a9618f15ce77fe051009abfc32e43419a268e0a2d64fa9c3a59a15114cb89871 -size 583104 +oid sha256:910210e4b628b5892da4ce322458d1dbbb4e395e9af1be334fe16558fec45fdb +size 587096 diff --git a/data/graph/adjacency/in/part-000014.parquet b/data/graph/adjacency/in/part-000014.parquet index 1843dec588343278881473f3b48175abf7e27fb5..5ad50e886499922335e51713547b6eb736559da4 100644 --- a/data/graph/adjacency/in/part-000014.parquet +++ b/data/graph/adjacency/in/part-000014.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:c26fc03cfe0a9485bfe0006afff22f4508cd0a95024db1d13f11ac763c6026f7 -size 484578 +oid sha256:ecc6a5790e623038c8c0fe795fba9466e2acafd3d4049c2a3e410d39a9dc8a6b +size 445462 diff --git a/data/graph/adjacency/in/part-000015.parquet b/data/graph/adjacency/in/part-000015.parquet new file mode 100644 index 0000000000000000000000000000000000000000..fbe9d5df3b77905bac3d31ed1728317cdac1939d --- /dev/null +++ b/data/graph/adjacency/in/part-000015.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff5b1e990e058fc2749f4a0dfd5f7a30f6e0d8ac8ddb046055bff9e214f12259 +size 583831 diff --git a/data/graph/adjacency/in/part-000016.parquet b/data/graph/adjacency/in/part-000016.parquet new file mode 100644 index 0000000000000000000000000000000000000000..b8dc17507275082c6073461ad9151eec82dc844c --- /dev/null +++ b/data/graph/adjacency/in/part-000016.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:324f95c4721bf69ba70e29e6be5d1d5b83312a71e8b593c32a349ed1316d049d +size 327876 diff --git a/data/graph/adjacency/out/part-000000.parquet b/data/graph/adjacency/out/part-000000.parquet index b5b2281dd0cffdfea72a924454b8121533b7d86d..81a5742195e064bec1392ad93d89b30cd793138e 100644 --- a/data/graph/adjacency/out/part-000000.parquet +++ b/data/graph/adjacency/out/part-000000.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:cf335683e5a5006c04f40fb0a785ab3d42d32a368613bff5341ec8c276c0fc25 -size 416832 +oid sha256:e013d34330aae2658c9fe883058c8826bc897ec6ffceb3236b5ff8cc869068e3 +size 421415 diff --git a/data/graph/adjacency/out/part-000001.parquet b/data/graph/adjacency/out/part-000001.parquet index ad97fe90a2a7fc9d071072a673cc72c2c7d2597c..3bba89a87f3de1c17bc6f2456e07a018bbd6f139 100644 --- a/data/graph/adjacency/out/part-000001.parquet +++ b/data/graph/adjacency/out/part-000001.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:b13878c8d2045d079e7ba6d6b38d4b09782777537fbd611a3fea4a22875dbe1e -size 416566 +oid sha256:43b937ac7e4d6d111c6dc58e563957da0f3ce6709c9db3f4b2eb9d1c6008a68d +size 422781 diff --git a/data/graph/adjacency/out/part-000002.parquet b/data/graph/adjacency/out/part-000002.parquet index cec744abfe67bf373e4dae1cba81ea3f1ba18cd6..31d4febe2f285bc39ae0d388fbc040d39911134f 100644 --- a/data/graph/adjacency/out/part-000002.parquet +++ b/data/graph/adjacency/out/part-000002.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:2dd22f6bc299299ba41e2d7975a6dbf6ca788c1e7239a025cd97ddc832e5cae2 -size 415268 +oid sha256:4e62a1869b9b10b1bd4299259faaf096b23c73348725ddf90a6430b2f6d4721e +size 422970 diff --git a/data/graph/adjacency/out/part-000003.parquet b/data/graph/adjacency/out/part-000003.parquet index f7775cb00debcec07abe45edc789413b95fc3efa..d60730452994c5ace21876d3342eaaa5ec95cff7 100644 --- a/data/graph/adjacency/out/part-000003.parquet +++ b/data/graph/adjacency/out/part-000003.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:33dc114448141ae940dbf94183cd5c23e1b56eef543e07e48bddbfa96cf79607 -size 418082 +oid sha256:45ac9697e4f16c425c2ea411bd0f4530a484340d4f09ed1b16823711f7b71da4 +size 424419 diff --git a/data/graph/adjacency/out/part-000004.parquet b/data/graph/adjacency/out/part-000004.parquet index 33bece59b47e41996ea299ef9ad2e8633df62cf7..9e9706348d35618c0faeb111036fb36685f43f73 100644 --- a/data/graph/adjacency/out/part-000004.parquet +++ b/data/graph/adjacency/out/part-000004.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:f76434d37dec0716b6ca09fb647915bec0d7af3c21437574554e2f37174a8d83 -size 419949 +oid sha256:b8abd0b2ed4394738e36277d899f95331c1c43dbff0770c77a289716dfda46e6 +size 424525 diff --git a/data/graph/adjacency/out/part-000005.parquet b/data/graph/adjacency/out/part-000005.parquet index d12644f770b1c774e0bfa6ee1f493e00525e89a8..c7959918793b13c3c55a9cd0e0bd22d1b5133aaa 100644 --- a/data/graph/adjacency/out/part-000005.parquet +++ b/data/graph/adjacency/out/part-000005.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:1f8fa9db4a97e20b5e059ec8c3b46c3933f31a42564e080469781f69d6ff07d3 -size 420592 +oid sha256:a1c26980aca6549161aaf1a9f80d6425c2bd3136f076f0ce883476011bb3027c +size 428037 diff --git a/data/graph/adjacency/out/part-000006.parquet b/data/graph/adjacency/out/part-000006.parquet index 0efba720c51d94e9297f2eb9e76813bd32e1c0c2..236160ba3002ea09a926fb3afc09b9708d558b12 100644 --- a/data/graph/adjacency/out/part-000006.parquet +++ b/data/graph/adjacency/out/part-000006.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:185c4dc6340abad26fbf3a8884d7deb2f56dc7bf0abf25e4bf007beaba74d424 -size 415693 +oid sha256:e7e9bc0442012e6f060bf14fadc93c30ce6342fa71c6cbd21228e93bf3505934 +size 423003 diff --git a/data/graph/adjacency/out/part-000007.parquet b/data/graph/adjacency/out/part-000007.parquet index 92e0c1b9b5ff300d9139bb35a2b6cc41db03f2b2..7c2dce1fd6a784793f83bbc45a40a7d22df03bbc 100644 --- a/data/graph/adjacency/out/part-000007.parquet +++ b/data/graph/adjacency/out/part-000007.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:cc6970a2d1d59b6a33682432ddbadf9f32c61ab54d386f467b69f1d04d028679 -size 416848 +oid sha256:798acc8b8b081d15745ec8ea923d8a6ec5de395de995556191fe607b29b3cf52 +size 421866 diff --git a/data/graph/adjacency/out/part-000008.parquet b/data/graph/adjacency/out/part-000008.parquet index 1fa83a1fb72f8fbde76a77f162f0b2f8b57f6fa3..46e4ec88e2496863267c2f6dae65ead48ddb3edd 100644 --- a/data/graph/adjacency/out/part-000008.parquet +++ b/data/graph/adjacency/out/part-000008.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:e5cad23453d3fa8e43f53c1a45b9bcb1836acef343c2da592b74f37822ca0e2b -size 418860 +oid sha256:496a79ac39342465b1d00087f9a04723a917d4c32bbfce38dfb427812d590c5d +size 425474 diff --git a/data/graph/adjacency/out/part-000009.parquet b/data/graph/adjacency/out/part-000009.parquet index 425b1fc86349cd7ccc5afdd5f5fd252d05bade1e..90f73f7666d1eaeaa94bfcfb20242066f15ac0e6 100644 --- a/data/graph/adjacency/out/part-000009.parquet +++ b/data/graph/adjacency/out/part-000009.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:4bfb8ff5c0cad92a050cb863864fa6d84442c2403ae499dd58dde90571882f02 -size 418145 +oid sha256:4c316cbc37767e33d6fa790aeaccb3afffa61c350603dd66de64d07c45960cc1 +size 422051 diff --git a/data/graph/adjacency/out/part-000010.parquet b/data/graph/adjacency/out/part-000010.parquet index 8a29efee9a5ef7be2fd7917ec427015e867c1d29..479030b99468ce50582dcc24b6d7e1b70deeaabd 100644 --- a/data/graph/adjacency/out/part-000010.parquet +++ b/data/graph/adjacency/out/part-000010.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8210e1e1f484e8d1995dcbf018f118a1dca6c9713bb83f77fc024800b32d5eda -size 416763 +oid sha256:0ff415f733dcdf9ee02691948b1e2013df2f8abcb1c6c27d600fd9c734c91f12 +size 424249 diff --git a/data/graph/adjacency/out/part-000011.parquet b/data/graph/adjacency/out/part-000011.parquet index 3b9954521c920a275328472ba6b6d7745b87d3d0..ad2d6d2c443f4b4abfbecb9afa7b3f4efa1d076c 100644 --- a/data/graph/adjacency/out/part-000011.parquet +++ b/data/graph/adjacency/out/part-000011.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:9e6849558001a5a2d959c75950a5c891cd936350dea1f50a94463705951dc438 -size 416958 +oid sha256:3a5d21c18dafd0337bca7a6a210fdcbf7832030d657cdbc79d51c8331c119977 +size 421859 diff --git a/data/graph/adjacency/out/part-000012.parquet b/data/graph/adjacency/out/part-000012.parquet index 4a83aed6c98a401911031956290048cd5302dad0..17b43123229134603ee7171ef00e62dad5113d06 100644 --- a/data/graph/adjacency/out/part-000012.parquet +++ b/data/graph/adjacency/out/part-000012.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:89ad05939644e28f5f50730d0282d194ca37fa2098b413fc2c23975c90a6c615 -size 415567 +oid sha256:eed2921927f7f129f2a63ea88e890042c666740f2cddf3bc3b208b4d45385d9d +size 424833 diff --git a/data/graph/adjacency/out/part-000013.parquet b/data/graph/adjacency/out/part-000013.parquet index 44d02768c8620f29ffb33e3b9a6f954d749892ad..b147a771877d1faaddfc2411757aee3166f545c7 100644 --- a/data/graph/adjacency/out/part-000013.parquet +++ b/data/graph/adjacency/out/part-000013.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8af91cfbd5375e06c24ac04b324e7860361caed0d0797c9414772a2d26c0253a -size 418813 +oid sha256:0dbf0e87756a640e85df6d86c73e70807a32e9236c787de646fe1b49d2a7df33 +size 423474 diff --git a/data/graph/adjacency/out/part-000014.parquet b/data/graph/adjacency/out/part-000014.parquet index 73f97f862fa0337f37e945819e44602f91170797..21270f0f72d7fc81ba5ed32eb8f96d1848126c1c 100644 --- a/data/graph/adjacency/out/part-000014.parquet +++ b/data/graph/adjacency/out/part-000014.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:df8d505b03f37f36e7603104fdbd49afc1e282d0638777c10d3cd63f47177c78 -size 9888 +oid sha256:322b2c857d38304a8e577399e57c854797927691f1c8c677dbb9ca57db8cd222 +size 423305 diff --git a/data/graph/adjacency/out/part-000015.parquet b/data/graph/adjacency/out/part-000015.parquet new file mode 100644 index 0000000000000000000000000000000000000000..8df54a1757652333417cce8b1eaaacde0f61b8da --- /dev/null +++ b/data/graph/adjacency/out/part-000015.parquet @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2dbe7bedf19755c2ab3231336e3d24bb5ef9b91aacc8fef8a96f0bbccb4e0cfa +size 308884 diff --git a/data/graph/edges/part-000000.parquet b/data/graph/edges/part-000000.parquet index ea5d511e4e4a620f22032add41712dd54082556e..50e5111d171edf33aeb651b87add131abd9dcc76 100644 --- a/data/graph/edges/part-000000.parquet +++ b/data/graph/edges/part-000000.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:c1bc565429f9e992e574910fbbc4c11de4aff7593b2026b18ebbff8fa2f344f7 -size 327601 +oid sha256:7056d729cb3ba2c08517b51aece371a64267cf21eaff25cba51b1505c9944452 +size 332032 diff --git a/data/graph/edges/part-000001.parquet b/data/graph/edges/part-000001.parquet index e13d4c314215eb8074643de6df9087be5f1fb8df..9f2cddc5366cd77e23e394f3790dcfbdc0c43c27 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:de7ed8de795ed7d6bf0443d02fa40c7625567fcc17d7d7a9f5cf61de4ea94109 -size 327011 +oid sha256:1a5562af724100f8f326f770929985cfc94e24bd0745d61210c18bd858084392 +size 331954 diff --git a/data/graph/edges/part-000002.parquet b/data/graph/edges/part-000002.parquet index b5c1e733efb57356a4c6f66641ce70d8e1e9d694..4206b94d8afe94768ea32708a6f64f9aa67f4d26 100644 --- a/data/graph/edges/part-000002.parquet +++ b/data/graph/edges/part-000002.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:6485abf5431d73bfac69fb7081b1495c0abab637094caf259cde9d4cb68720c1 -size 328826 +oid sha256:e37edf83ad9a33c37132885220e90a7514a8cccac51f811b6e9437fff5c2b5f3 +size 334671 diff --git a/data/graph/edges/part-000003.parquet b/data/graph/edges/part-000003.parquet index c5e00735e076466ef8f75f3852c7560ea894604d..f73eb53aff125f0a1067154e95b2ce72de01296c 100644 --- a/data/graph/edges/part-000003.parquet +++ b/data/graph/edges/part-000003.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:7629bfac04502f8fec9b046072f356fc28a35171c98d78fbf62ec67f40b3d57e -size 328514 +oid sha256:b96b569c491824a28fcb6b88e4cadaf3a2d35c1b5c0fcf74158e42260cc7d196 +size 331619 diff --git a/data/graph/edges/part-000004.parquet b/data/graph/edges/part-000004.parquet index 47cd368a390a35181371525c6d01b564d9cf4f17..d72b80635e7b5087c5820f0750c6598a0aa5d06e 100644 --- a/data/graph/edges/part-000004.parquet +++ b/data/graph/edges/part-000004.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:7f439fb3a9be18545663812efb50bf84e4d316f0ecfaa758457c8fb442a87225 -size 329046 +oid sha256:c342a2d1244c65cdd7246ca5a2a900f68b10940c6eb12ec28a038b9b72485e93 +size 332977 diff --git a/data/graph/edges/part-000005.parquet b/data/graph/edges/part-000005.parquet index d4acc223ded92174d1ffd56b37dd2d69b3ebf17f..b2af0f5440732696b944897d421c0ec0c32d07bd 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:7f21832ae309dabe60f9091b466937e091f8f698bb96f48ce317d1aa0956b6f5 -size 328951 +oid sha256:88ebea169ba3166d2d9cf18087163ee412bc1deefa6b801542891e974b36438c +size 332837 diff --git a/data/graph/edges/part-000006.parquet b/data/graph/edges/part-000006.parquet index 3944729fac69f01ca948884dce6c8ba3d1ba2b2c..20fc9348d7c0fd7a774d786b281374c720158136 100644 --- a/data/graph/edges/part-000006.parquet +++ b/data/graph/edges/part-000006.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:89bcc750d24b86853a63ffe8cee0748e406601dbae48c7289dbb6ca608bda5e9 -size 328478 +oid sha256:21a744a40d4deb607d6141350aab495a3f55c6df113c0715497516c9fb6e3a53 +size 333198 diff --git a/data/graph/edges/part-000007.parquet b/data/graph/edges/part-000007.parquet index fca2c7c1385fb5cab53e033ad8116bdea2c3b355..9c7d7ec71b48b1b2f608adfb5fbec6ea5d33bf1e 100644 --- a/data/graph/edges/part-000007.parquet +++ b/data/graph/edges/part-000007.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:3eb3842f898e5ec707522ef0eb3e62dbb1a81238ae62f7e194740fa26990549e -size 327432 +oid sha256:29882ab1f7847f24d19e5a154f10946b6806dc0769e4c05ffa9dbe0931b162d3 +size 333305 diff --git a/data/graph/edges/part-000008.parquet b/data/graph/edges/part-000008.parquet index 33d1a02810335bea195285f857d741e5cb0eebe6..39e09a6c8e2094a435707d0a781f9be522a8c4e9 100644 --- a/data/graph/edges/part-000008.parquet +++ b/data/graph/edges/part-000008.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:c535586d0f71ac8448bee79ecee43f1d82fdfe1d2a536951db284244204f5d47 -size 328120 +oid sha256:de4e30d952655826b4d42ee32531d42d6d7ad23825f097caf2dd689402559b2c +size 331947 diff --git a/data/graph/edges/part-000009.parquet b/data/graph/edges/part-000009.parquet index ca66f439edcf56d0c78a55779839b3fc4db14838..2926708cf4684554f1534421bfbe26c712c467fa 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:6a6446fe317b1aa010a1e3ce51f4f8df47633a818ea64de9d5f8ba23c263b512 -size 328902 +oid sha256:6e37b66de4ee7bd86ad0dfe7c78e7ffeb33fd7b74e670e072f7a95fb67a67259 +size 331834 diff --git a/data/graph/edges/part-000010.parquet b/data/graph/edges/part-000010.parquet index b48cc725a43404e5afd5937b4fe1fa62af338469..2eb14720acc5d61574ed6de0cc03ee97b8f915f9 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:a927167933e15853351e59ca4574067aa9f82c439b598bcd8f8082bccff24b08 -size 328330 +oid sha256:ba5848efce5c908fb2da15e33f2c4c9005179ce0c48c7dc9a3d2af1f2719f00e +size 331694 diff --git a/data/graph/edges/part-000011.parquet b/data/graph/edges/part-000011.parquet index 8146da4e76a82dccf437898b8d0b5e2261e0e5d9..98b0806aa7fbd6bc250012641b6196895b7e30f4 100644 --- a/data/graph/edges/part-000011.parquet +++ b/data/graph/edges/part-000011.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:80970d22c357768a207d2f241ba2cc285fc776545d51501d7f93c0dc404117c9 -size 327371 +oid sha256:e1f817d9607c5cda29d3086e66002c06b165cfb246b43fa534187075c718b189 +size 333385 diff --git a/data/graph/edges/part-000012.parquet b/data/graph/edges/part-000012.parquet index fec00e91ee0bf73ee3b868f6b3a0a063797e8f17..5bcdcbd2371670f5b86a28c9a261bffc7e51b5fb 100644 --- a/data/graph/edges/part-000012.parquet +++ b/data/graph/edges/part-000012.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:7d2cf4ab3920a6637dca6aff5c19556cc9e4d1b13ed49f3e5d15c974ccd9fe8c -size 327629 +oid sha256:0677849f6f1948fd78eca5a0b7e8e0b2870e1797f72283bec8451abddc2b0ca0 +size 332838 diff --git a/data/graph/edges/part-000013.parquet b/data/graph/edges/part-000013.parquet index c1a4573a9267fb459f8baa6a70b96a266d5cb38a..78edff96829dd42d28c3e1fdd9f88a32efab6717 100644 --- a/data/graph/edges/part-000013.parquet +++ b/data/graph/edges/part-000013.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:79c48f8bc202405a98648e9eaf575c630c3994c656fab214f4754797718c7dcf -size 329670 +oid sha256:b8f8ef10374370d0d964a184d0c12dca7fa607aa52195b5fcd0af26e068a75cb +size 333370 diff --git a/data/graph/edges/part-000014.parquet b/data/graph/edges/part-000014.parquet index 65e06fd19d254d944a2cebf5a2465f7be30a8085..cb5be21627cd4f7aebaad4bcb1b452f0c333d8b3 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:6ec381ea863b49ca505b3c47c3ddb9ace0c52de9a5a0ad1554d7ac2cdf8ccaea -size 328393 +oid sha256:6968e530f2e9db7252e1ad8be6a3375509062a7bf7394749e2e23108b88c3fcf +size 333457 diff --git a/data/graph/edges/part-000015.parquet b/data/graph/edges/part-000015.parquet index 3702c4644ea8e54663477621cbc2e7fe7ddae71d..5498eb287ef61d73859fb9762c8bc5e7fbff2d86 100644 --- a/data/graph/edges/part-000015.parquet +++ b/data/graph/edges/part-000015.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:a6b8e0532919b694e5daa07484abbdf708bc395f9f3f6d5a45480b264abc2731 -size 329068 +oid sha256:f8cda02c9b81abdc799910bf34bb8b9be3844fa5ba01b25fdfbfb41141f559f7 +size 334334 diff --git a/data/graph/edges/part-000016.parquet b/data/graph/edges/part-000016.parquet index d39d40b81092c168295ace5a658cbde6b4a505e3..df1efb6f4130d05d7336be77ebb5bb085bf5beed 100644 --- a/data/graph/edges/part-000016.parquet +++ b/data/graph/edges/part-000016.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:fdaa34f529a229cacc2c4dc1f50bee7ec5a5dc65f9d0d98d6b89710204ab8b1e -size 328483 +oid sha256:344e249407757b5129485347cb2d98d77238a858b372c12e3f750a6a686dd9af +size 331851 diff --git a/data/graph/edges/part-000017.parquet b/data/graph/edges/part-000017.parquet index 0051905408b78bd723a37e16d7521e73159a180d..0ac1988d19d0badcaf3918d2fcbff7114fd6cf3d 100644 --- a/data/graph/edges/part-000017.parquet +++ b/data/graph/edges/part-000017.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:cdaa1a29a07c35abdf2e9278ea4b24f8f2ea706a159fd5a0406dffc2862d5542 -size 331604 +oid sha256:69156e2ef4c0c229881f16f0862aabfc95dc255a32a864d00edaff69b55c1e7e +size 332891 diff --git a/data/graph/edges/part-000018.parquet b/data/graph/edges/part-000018.parquet index c50b88477b07adc24550f223ff377981f0a07caa..ebf3bb7ec95b410d6e101221e1d477382dfc370d 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:8c059cd3afced5cc0856a78d98f194b5ecb5d9051a1d9d7005df7820b3985589 -size 328297 +oid sha256:548bb8194c0bba90cf3a13b59ab9eeb3390f5b44cad46a7c764e0dc7c278f3b4 +size 332528 diff --git a/data/graph/edges/part-000019.parquet b/data/graph/edges/part-000019.parquet index 7692301f65ca4d450083498ffa1dc8cc704fd642..3c52fcf40397b6c2f76b9b8c6aec990769d1c56a 100644 --- a/data/graph/edges/part-000019.parquet +++ b/data/graph/edges/part-000019.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:04b850908bd5a4f5ca2fa1190b08a8fb909aafd08caabe1c2d9eedcee50de1a2 -size 325880 +oid sha256:95ab3ac1b8c24d4bfdf0700b359125773640a7688fa762d968903234a89875cb +size 332586 diff --git a/data/graph/edges/part-000020.parquet b/data/graph/edges/part-000020.parquet index 69aaf0a0d8695978e670dd9db0636f37d32e0bc9..abdc4852a26f7b0250562faf0c50b5cb8605b43e 100644 --- a/data/graph/edges/part-000020.parquet +++ b/data/graph/edges/part-000020.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:ab5cd636dfe66c02ca6cbba6a4e1407b5491dfa3a538a35c6ce306dfa0db3b66 -size 327790 +oid sha256:f758055c9ae84841f6c0e7c6a99bd466333b11d1a983e69bbf3130b6082d87d5 +size 332390 diff --git a/data/graph/edges/part-000021.parquet b/data/graph/edges/part-000021.parquet index cbc0669f6c48cc0d02e3bdaa1442fb3c01834be5..fdfe6c84fd76f03b1e2258d7a50ef6f99b04e117 100644 --- a/data/graph/edges/part-000021.parquet +++ b/data/graph/edges/part-000021.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:89f53ac0ac5d40feede1eff393e6e3b57dfefb3dc442390475453648416709aa -size 329482 +oid sha256:afb1e4e9f42a1c68a671baa299475416496423ddefe6d0902a396c21bcafc1d1 +size 335064 diff --git a/data/graph/edges/part-000022.parquet b/data/graph/edges/part-000022.parquet index 5f70095c9884f3a997cb554b53276834775b6b50..05e4821730c49999c256361e09a202c1b85ccec3 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:c89dfed34d6e54b3fe675aea7a0be0744899c0307fafd69db0bf5402f52d17d5 -size 328727 +oid sha256:01e66ea08533c520fe02a806c53b4189b41ce7007a06a6dcdbd483dbcb6be886 +size 331663 diff --git a/data/graph/edges/part-000023.parquet b/data/graph/edges/part-000023.parquet index 41876f27aea404db40147a867d28319ca21cc38e..1f2ac3e64892b9bfda7b1c121991f122c944b429 100644 --- a/data/graph/edges/part-000023.parquet +++ b/data/graph/edges/part-000023.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:691a276cdc1d1835bb1efe60ed7134522082a8511ce7a716bb4fe22549c176c9 -size 328874 +oid sha256:f09739d492f22f573dc2dcd6c6cfaa85b92387c4b7bda72483be4fb29d367758 +size 332148 diff --git a/data/graph/edges/part-000024.parquet b/data/graph/edges/part-000024.parquet index ff6a18530b360e660f12cec6da284e896c100fd9..fddeb450b27aa5c7c7d4f9d7062a82c1a56ce884 100644 --- a/data/graph/edges/part-000024.parquet +++ b/data/graph/edges/part-000024.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:b9a7b2d7082017cd194c9defa6f574c57a008a1d692ed3db6f7f130b885b5f00 -size 329280 +oid sha256:0d0a028000364af69667e77a40f7bb0214152b4f49ac6d421ec35bb11afaea0e +size 333809 diff --git a/data/graph/edges/part-000025.parquet b/data/graph/edges/part-000025.parquet index fda1ec54800a2882be0a6e0fe0dfe0fa8074f588..3a97baff346898135b1f134b61389dfb05aecf77 100644 --- a/data/graph/edges/part-000025.parquet +++ b/data/graph/edges/part-000025.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:8673c2f3b995e82abde64f2d427e8b5c5d7c4d0361a68bd5d44d379181d01502 -size 330533 +oid sha256:0647fe2b47cbd2024d53ae7b81d1e7403e7b5e33e3e6bab3a29b67c5902235ff +size 330285 diff --git a/data/graph/edges/part-000026.parquet b/data/graph/edges/part-000026.parquet index f5e82f0814f461cfc6e5e281a067b630649e2eb4..e8785c32891fcbe1db6840b86e5b005ef4873e0b 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:9dc615778cd5c465e444e7715fb8b33dbafb1eb99934a3efb4d83d2792edb6b6 -size 330066 +oid sha256:69693d5d406a060c19c5c4fc9e30bd4bec2fe51bc1bb871d43dd8ec26bc91b51 +size 330775 diff --git a/data/graph/edges/part-000027.parquet b/data/graph/edges/part-000027.parquet index e2fc320d85c1f55b4b3f37253e88363726aafe30..3e100d562b2724bcb78e69006516966ed752ab77 100644 --- a/data/graph/edges/part-000027.parquet +++ b/data/graph/edges/part-000027.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:fc80cf4399890ece86d3f4e84e0cb8715aaf295b54e59e9c79f18d8bcee00f87 -size 328403 +oid sha256:1ef8763bbb79c82290c0e7b17dbb7a0dc8d65c8cdaee5b24214273b69abeebf9 +size 333936 diff --git a/data/graph/edges/part-000028.parquet b/data/graph/edges/part-000028.parquet index 176e58f4d4aa478964eca910c0328fbb03c1ae4c..47b2b1f8265b88fcbee986d3459640ac443b8265 100644 --- a/data/graph/edges/part-000028.parquet +++ b/data/graph/edges/part-000028.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:311f923e0fd6be64d3573e81b22a8b723257ca3cc69de3c07d84d669808bb090 -size 9229 +oid sha256:1d0dc645c9d89e8d7c2f22e1275b7415bfc5770b818b979a01c4b0d73ed1efa9 +size 331706 diff --git a/data/graph/edges/part-000029.parquet b/data/graph/edges/part-000029.parquet index 0c50edffbb77f4b5b3fe57e29ac2d8326b27e4cd..27b49bba2a8a364ceed2522ff2d605dd6007ba97 100644 --- a/data/graph/edges/part-000029.parquet +++ b/data/graph/edges/part-000029.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:b49e14b396690de863178b2473d371834a31888c5649a43020e2255e41565b0b -size 294627 +oid sha256:91a39f17d5de4711226696d6d29f2070ec269251742acc73e9ae3450ba974b3d +size 330262 diff --git a/data/graph/edges/part-000030.parquet b/data/graph/edges/part-000030.parquet index 0df6c2acf712bcac726e3208e3a91a70c553b506..5cd039317c3b791f90b139c968dc99c949aed0b8 100644 --- a/data/graph/edges/part-000030.parquet +++ b/data/graph/edges/part-000030.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:41406fe671b9bda653b8f6893a5019dde3f4a0803da60f9d61f64b261e7f3053 -size 305074 +oid sha256:3a87a353b92e0f778dc45b66d69309c085fa7dcd0ac1bf01ac7dfbc4575b3801 +size 332130 diff --git a/data/graph/edges/part-000031.parquet b/data/graph/edges/part-000031.parquet index 3d73c9065c2686ef7cd2dd5b5917f737673ff2d6..a542c851f01b767b687be1f1bc349e682e4b6c7c 100644 --- a/data/graph/edges/part-000031.parquet +++ b/data/graph/edges/part-000031.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:d89031934977203525daa33fdc453a17ad0f5a49af33de6dd64b84b2f67690bc -size 302795 +oid sha256:6c858b055b06c03fe8dc58583875ef2f21837429a2d2c7d53915e27d02522e65 +size 145695 diff --git a/data/graph/nodes/part-000000.parquet b/data/graph/nodes/part-000000.parquet index e706be44ec0f6cddd57dfcbcb16384caa8fe7637..1f709391f9494c21c29554657cd4ced8ecf8d61e 100644 --- a/data/graph/nodes/part-000000.parquet +++ b/data/graph/nodes/part-000000.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:a764d0b08aaca2f16aa184c35cc8a0843be1663c2a84435c31574ee2c7361c14 -size 323102 +oid sha256:7507092706d57d5bcc134939c532e941bdca222d5fd7ab3fb27863f67537d96d +size 330713 diff --git a/data/graph/nodes/part-000001.parquet b/data/graph/nodes/part-000001.parquet index 9e669a20bebb994e7f2ad5a572624dd48403de86..de545780b7313458a01453703d35a4e955736941 100644 --- a/data/graph/nodes/part-000001.parquet +++ b/data/graph/nodes/part-000001.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:40e7ddd57f069445816d755a0f45f2bf7ee4eb93318b72cf48bbf65c694fd6dc -size 323337 +oid sha256:234461c75661881918b13c368caedd009ed9cd40096dfbc5193526112051c112 +size 332600 diff --git a/data/graph/nodes/part-000002.parquet b/data/graph/nodes/part-000002.parquet index 3220f43de694f0bcec0bd4bec00f968a325379c9..d9a2232fdaffdbc73cb28c863ad850cad130bf95 100644 --- a/data/graph/nodes/part-000002.parquet +++ b/data/graph/nodes/part-000002.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:23de293e57c9613b1c0eac0efdb5e837bdb9d8e355d588859acbdfbcd4bdbf94 -size 321922 +oid sha256:22d2fca90434a4200adf82c9aea895bf0d62d11acee76bb0e7dcf2694f972e03 +size 328497 diff --git a/data/graph/nodes/part-000003.parquet b/data/graph/nodes/part-000003.parquet index 051c16f525e0e8900761d17894436b22baf40c44..ea3f25eaf46313705c25a1e7236cb44da361e532 100644 --- a/data/graph/nodes/part-000003.parquet +++ b/data/graph/nodes/part-000003.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:99c6f84aafb2c606ffcab8989bcc87b701b6abbff56d9b0bbc0a2a8262eab56b -size 326512 +oid sha256:ba500f8db6978814462df7e2a88e6ae57973f1c7a03927d5c48b840e4841f1a7 +size 331338 diff --git a/data/graph/nodes/part-000004.parquet b/data/graph/nodes/part-000004.parquet index a6f43a9145876ea31a65fa55d8cba48718476c2c..0cb48659f48b9901694300a84cf87c9beafedbdb 100644 --- a/data/graph/nodes/part-000004.parquet +++ b/data/graph/nodes/part-000004.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:fb5086f0e738a053d8b9d737a7e521f72241aba1732e82723fc21c6ba31b1cf2 -size 324638 +oid sha256:49afe21a4050e2bb43a7b07fe5442f819fec4c4ca152965ebfb5467d9f6b7041 +size 331057 diff --git a/data/graph/nodes/part-000005.parquet b/data/graph/nodes/part-000005.parquet index c4163b2f142cc3f05b98d5ff45d20d6e8e5aafb1..06b55fc27eaf5b2891a282a06b7700fd53faaf09 100644 --- a/data/graph/nodes/part-000005.parquet +++ b/data/graph/nodes/part-000005.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:a7a681522770ed27b6d23ee8f711009c3d6938cba075a8563b358886a7aa9702 -size 13956 +oid sha256:b636a214568cb308dd48c38387903cfd24f706f2b0f82310e26b68612e1eb348 +size 212976 diff --git a/data/vectors/part-000000.parquet b/data/vectors/part-000000.parquet index 252e54ae8e9c3960fe1fb0ae1ad20a0d4ffd16e2..5bc745e94780556dc6f8885b4fefb70887009f30 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:e74d4745dba60d9b97cd2dc58f8f89cd4fde76dd479c91ef43f91555c3a794ca -size 6856646 +oid sha256:952ea9eacc5d4bc85734a3e40efb605a658351263e822dccafc9f2f5694d71b4 +size 6809401 diff --git a/data/vectors/part-000001.parquet b/data/vectors/part-000001.parquet index a0748ac325c2ea5eefb5c49bd473b74ebaaf4d07..e1230a3ba036a7f9c03ce98021b978de9f5fa6d0 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:f76b173578c1793bff585611adc7a7fc4c84cbe30bc941d19f02edf05e5ca778 -size 7025890 +oid sha256:42514888ff4d8d87a87fe7c5a0b0607d174eed738491b1351d98676b59e6cc4e +size 6231044 diff --git a/data/vectors/part-000002.parquet b/data/vectors/part-000002.parquet index bf6a8bff3b3d23099fb90e4a50a693b5241f820c..25fb8e4ee6153639de3b92bac087240946d24847 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:6c1f52047cf34e7080cb64b0dfcae7822fe27c890d42ff01bd3a57c7d5823347 -size 6471231 +oid sha256:439abe9397a890b9e5cec76384b4ced5c0144924a43528e6eb340189684fe49c +size 6715734 diff --git a/data/vectors/part-000003.parquet b/data/vectors/part-000003.parquet index 0666e7dcb3e2dd639350fff003d7b363c2e75c77..cee5ca32ee7e92bddb83ddc9929895ed2a77da32 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:220ee96e483ae3964b22543089bee007a5512a0dd4a2deb970662ae7ce586a7d -size 362589 +oid sha256:4d2b7991f1fe42d4e7f23625d1824037327678536d8a9353a547f725f3917a9e +size 6696796 diff --git a/indexes/bm25_document_chunks.parquet b/indexes/bm25_document_chunks.parquet index ab0689c9a17e740be6ad0f8c3c96decd56d18e6d..d029d1cfa10511a643be681c32009a7a88738a1c 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:5fc13d47bfc980986f06008cb34aac770c3ffa35e030fa7e3b6c6366d0529c7c -size 5124 +oid sha256:5809397c47b0fe559a0610550a36775f8993f93ed60514bf7f95931d72b1275b +size 5127 diff --git a/indexes/bm25_keyword_shards.parquet b/indexes/bm25_keyword_shards.parquet index 53da3dce7a065bdd206627629e95853bb4614829..3ab191873c41e158df98a5f22663d3cedcfd5c6d 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:a2c65bad0b988c69205b832649bca27b82feb15b97881b2a9792ab172d5fcf2a -size 6484 +oid sha256:2bd94556a43afe30032149dbfbde489389202322686d6fe40562d3a8079c807b +size 6617 diff --git a/indexes/corpus_chunks.parquet b/indexes/corpus_chunks.parquet index 81134ca1fe06c4ccc99ca046f44fba525f2117de..ef6a15fff10d01af8c247948e5079e270d3a456f 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:d2930372f417eac004fcf840dc3e1f02010457bb10b0ef8c06c2a74b57cd0b5b -size 9131 +oid sha256:d8f4fd7214f5470be5d7eb9f25ce1574c35721cc56e96a00f14951770f6f7faa +size 9140 diff --git a/indexes/graph_edge_chunks.parquet b/indexes/graph_edge_chunks.parquet index 244e45e5c633e43f1672141f22f776c06d4ab9a1..279d04b90e2def8a0c5ddd2820d6442925fb271d 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:40b0971707b36ffaed62569d36cf1c46c92d7e8d62027034534d99e2f0a81a89 -size 9920 +oid sha256:c2b3ab7bd62888d1cd1704ea736f64db890e246a7477b7e781c4eac30e73da9f +size 10456 diff --git a/indexes/graph_in_adjacency.parquet b/indexes/graph_in_adjacency.parquet index dc5e1004a3303842de94086b663453b570f4ef29..2639b322c8cf1f95c5e2094a22cc0e5edf3e1062 100644 --- a/indexes/graph_in_adjacency.parquet +++ b/indexes/graph_in_adjacency.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:d9e6c658ed49eb3300a3a4c9cf371ab35e4c74c00dd6850e2f1d38fcacd285cc -size 9001 +oid sha256:1269d3244b9be5322b4bc583667a2dcc78e5fb47466bcff8430fa4b6ffd073ac +size 9394 diff --git a/indexes/graph_node_chunks.parquet b/indexes/graph_node_chunks.parquet index 669c0ad1347587ecadd360554f68984075e60e09..feeadee2831d28df9e7e6ee29bd8647e006f1c7a 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:8d84975b5d7fcf47117fdb318365763542ee2c306364d62d066e9dd0aaf31985 -size 5788 +oid sha256:1b0cd1167b93ac3a6feb17af069969393987dc9c9532f4e29ac915bb3a72f49d +size 5792 diff --git a/indexes/graph_out_adjacency.parquet b/indexes/graph_out_adjacency.parquet index cbc76730ddb53d5241de55f5aa716a4fb0ed2dba..61f99a7b8dd4001f86daa6f67f389e20eb435d20 100644 --- a/indexes/graph_out_adjacency.parquet +++ b/indexes/graph_out_adjacency.parquet @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:fbfb40692f48011ee0c3ac860962e04fef25ba503d06a81f1aef7147ebffec8c -size 9031 +oid sha256:8a3ca42a513743d1ceadc1fabad0b579e6f7cfccf9fb95bbda27555b1ec96a13 +size 9185 diff --git a/indexes/vector_chunks.parquet b/indexes/vector_chunks.parquet index 3a1182c1f5a33182cb65ead6ea06842002ae233f..a763bb339b6682ec23b433f02034f289dbedbdd9 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:3dfebe5ad199e44553ac732e3c43e52d954e8dd967f4c8100480d8fdae965bad -size 31972 +oid sha256:8b0bb8bee89cb16ae484be6bc1052b04208346d2e2f5a587dc09c086ecd314e1 +size 31969 diff --git a/manifest.json b/manifest.json index 375f944b26286d266937b24b2243864775fedd92..d5df13756bb10b1bbe484d34be684eec271ccbcc 100644 --- a/manifest.json +++ b/manifest.json @@ -19,7 +19,7 @@ "b": 0.75, "title_weight": 5.0, "body_weight": 1.0, - "average_document_length": 280.41659114674104, + "average_document_length": 492.495460199005, "tokenizer": "hf-graphrag-bm25-tokens/v1", "max_query_terms": 64, "posting_rows_per_record": 4096, @@ -27,28 +27,28 @@ }, "counts": { "bm25_document_chunks": 4, - "bm25_documents": 14345, - "bm25_keyword_shards": 16, - "bm25_posting_rows": 63675, - "bm25_postings": 1546715, - "bm25_terms": 63616, + "bm25_documents": 16080, + "bm25_keyword_shards": 17, + "bm25_posting_rows": 67613, + "bm25_postings": 2428340, + "bm25_terms": 67529, "corpus_chunks": 4, - "corpus_rows": 14345, + "corpus_rows": 16080, "graph_edge_chunks": 0, - "graph_edges": 114760, + "graph_edges": 128640, "graph_incoming_adjacency_edges": 0, "graph_incoming_adjacency_rows": 0, "graph_incoming_adjacency_shards": 0, "graph_node_chunks": 0, - "graph_nodes": 20617, + "graph_nodes": 23024, "graph_outgoing_adjacency_edges": 0, "graph_outgoing_adjacency_rows": 0, "graph_outgoing_adjacency_shards": 0, "vector_chunks": 4, - "vector_rows": 14345, - "n_laws": 0, + "vector_rows": 16080, + "n_laws": 1735, "n_articles": 14345, - "bm25_token_instances": 4022576 + "bm25_token_instances": 7919327 }, "parquet": { "compression": "zstd", @@ -85,12 +85,10 @@ "max_rows_per_centroid": 8192, "max_shards_per_centroid": 2, "default_probe_centroids": 4, - "centroid_count": 5, - "shard_count": 5, - "n_vectors": 14345, - "status": "partial", - "n_reused": 12390, - "n_missing": 1955 + "centroid_count": 6, + "shard_count": 6, + "n_vectors": 16080, + "status": "embedded" }, "canonical_fields": [ "entry_cid", @@ -130,7 +128,7 @@ "articles_sha256": "5b62e48fd10bdf5f4d634cbb71899c9afde24573ea1b133213e97cd9cbcb2bc8", "n_laws_in": 1735, "n_articles_in": 14345, - "unit": "article", + "unit": "law+article", "article_law_coverage": 8.26801152737752, "sparse_article_fallback": false, "drops": { @@ -145,7 +143,7 @@ "duplicate_cid": [] }, "language_breakdown": { - "es": 14345 + "es": 16080 }, "quality_flags": { "articles_table_empty": false, @@ -169,19 +167,126 @@ "laws.eli non-null=1735/1735", "laws.language values=['es']" ], - "n_out": 14345, + "n_out": 16080, "never_invented_legal_text": true, - "n_before_dedupe": 14345, + "n_before_dedupe": 16080, + "n_law_rows": 1735, + "n_child_rows": 14345, + "n_instruments": 1735, "n_dropped_total": 0, "record_type_breakdown": { - "article": 14345 + "article": 14345, + "law": 1735 }, "jurisdiction_breakdown": { - "PE": 14345 + "PE": 16080 }, "snapshot_dates": [ "2026-09-03" - ] + ], + "heading_language_counts": { + "es": 389 + }, + "heading_language_majority": "es", + "document_language_majority": "es", + "verification": { + "schema_version": "country-laws-normalize-verify/v1", + "slug": "", + "admitted": true, + "n_checks": 8, + "n_failed": 0, + "failed_ids": [], + "checks": [ + { + "id": "nonempty_corpus", + "severity": "fail", + "passed": true, + "message": "normalized corpus has rows", + "evidence": { + "n_out": 16080, + "n_dropped": 0 + } + }, + { + "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": 16080, + "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": 207, + "n_bodies": 16080, + "fraction": 0.012873134328358208 + } + }, + { + "id": "parent_laws", + "severity": "warn", + "passed": true, + "message": "parent instruments present (1735 law rows from 1735 source laws)", + "evidence": { + "n_laws_in": 1735, + "n_law_rows": 1735 + } + }, + { + "id": "legal_structure", + "severity": "warn", + "passed": true, + "message": "retrieval units are structured (law+article, coverage=0.89)", + "evidence": { + "unit": "law+article", + "structured_rows": 14345, + "coverage": 0.8921019900497512 + } + }, + { + "id": "heading_language", + "severity": "warn", + "passed": true, + "message": "heading lexicon es vs document language es", + "evidence": { + "document_language": "es", + "heading_language": "es", + "heading_counts": { + "es": 389 + } + } + } + ], + "blocks_graphrag": false + } }, "schema_mapping": { "laws": { @@ -213,27 +318,27 @@ }, "indexes": { "bm25_document_chunks": { - "cid": "bafkreic7ye6upp6jqcmg6bqarszuvldxbq77unpagd5h4o3mmntnauu4pq", - "sha256": "5fc13d47bfc980986f06008cb34aac770c3ffa35e030fa7e3b6c6366d0529c7c", - "size_bytes": 5124, + "cid": "bafkreicybe4xyr5q7zkzubqqkufdm527rgj7spwwaukl674vsmoxfmjhlm", + "sha256": "5809397c47b0fe559a0610550a36775f8993f93ed60514bf7f95931d72b1275b", + "size_bytes": 5127, "relative_path": "indexes/bm25_document_chunks.parquet" }, "bm25_keyword_shards": { - "cid": "bafkreifcyzn22c4yrrusaw4deze3zit3ql7lcw4xransvf4svmls2x6pfi", - "sha256": "a2c65bad0b988c69205b832649bca27b82feb15b97881b2a9792ab172d5fcf2a", - "size_bytes": 6484, + "cid": "bafkreibl3fcvnjb27yyagikj3p554setreqcgitinvx6iblc2ouapheapm", + "sha256": "2bd94556a43afe30032149dbfbde489389202322686d6fe40562d3a8079c807b", + "size_bytes": 6617, "relative_path": "indexes/bm25_keyword_shards.parquet" }, "corpus_chunks": { - "cid": "bafkreigssmbxf5ax5laaj7hyidod4hycaecfpoyqwdxyybwcu5fvptillm", - "sha256": "d2930372f417eac004fcf840dc3e1f02010457bb10b0ef8c06c2a74b57cd0b5b", - "size_bytes": 9131, + "cid": "bafkreigy6t6xefhvi4f6lv7lt4s44fluynlsdtcw5fvab4kjkf3q6337vi", + "sha256": "d8f4fd7214f5470be5d7eb9f25ce1574c35721cc56e96a00f14951770f6f7faa", + "size_bytes": 9140, "relative_path": "indexes/corpus_chunks.parquet" }, "graph_edge_chunks": { - "cid": "bafkreicawclrob5tn75o2yswtu3m6hcgzewx5dlcajydiu2nthrpbka2re", - "sha256": "40b0971707b36ffaed62569d36cf1c46c92d7e8d62027034534d99e2f0a81a89", - "size_bytes": 9920, + "cid": "bafkreigcwovxxvrirdi42fye5jzw6zg3rehci2tuo636paoe5lbq4462t4", + "sha256": "c2b3ab7bd62888d1cd1704ea736f64db890e246a7477b7e781c4eac30e73da9f", + "size_bytes": 10456, "relative_path": "indexes/graph_edge_chunks.parquet" }, "graph_incoming_adjacency": { @@ -241,9 +346,9 @@ "present": false }, "graph_node_chunks": { - "cid": "bafkreienqslvwxl7z5drc763ggbwk5rvilxcymddmtlc2btotxikv4yzqu", - "sha256": "8d84975b5d7fcf47117fdb318365763542ee2c306364d62d066e9dd0aaf31985", - "size_bytes": 5788, + "cid": "bafkreia3btirm64tvq5g72yxv4djs2jzhgd5zhevgl2ofgwjcw5tu4xutu", + "sha256": "1b0cd1167b93ac3a6feb17af069969393987dc9c9532f4e29ac915bb3a72f49d", + "size_bytes": 5792, "relative_path": "indexes/graph_node_chunks.parquet" }, "graph_outgoing_adjacency": { @@ -251,9 +356,9 @@ "present": false }, "vector_chunks": { - "cid": "bafkreib5727fvumz4rcvhldtfy6ehzjnsvhi3wlh6tebabea3d625fs3vu", - "sha256": "3dfebe5ad199e44553ac732e3c43e52d954e8dd967f4c8100480d8fdae965bad", - "size_bytes": 31972, + "cid": "bafkreielbo4l52e4wfvojbf6npaqkkyeecbunuxc6wsypxajycdozuyu4e", + "sha256": "8b0bb8bee89cb16ae484be6bc1052b04208346d2e2f5a587dc09c086ecd314e1", + "size_bytes": 31969, "relative_path": "indexes/vector_chunks.parquet" } }, @@ -307,58 +412,57 @@ ] }, "incremental": { - "kind": "delta_refresh", + "kind": "full_rebuild", "mode": "auto", - "reason": "source changed; reuse embeddings for unchanged entry_cids", + "reason": "operator forced full rebuild", "source_revision": "b9d7781812a5fa8a03bc091b8f08b90b305282b0", - "prior_revision": "cda61f886e113debb0a3b5ba7a61a1f0763498f5", + "prior_revision": "b9d7781812a5fa8a03bc091b8f08b90b305282b0", "source_fingerprint": "b9d7781812a5fa8a03bc091b8f08b90b305282b0|fea22e08bc1e35d3021f3075a3193150334d5b4e25576a04cb97f9ba179b422b|5b62e48fd10bdf5f4d634cbb71899c9afde24573ea1b133213e97cd9cbcb2bc8", - "prior_fingerprint": "cda61f886e113debb0a3b5ba7a61a1f0763498f5||", + "prior_fingerprint": "b9d7781812a5fa8a03bc091b8f08b90b305282b0|fea22e08bc1e35d3021f3075a3193150334d5b4e25576a04cb97f9ba179b422b|5b62e48fd10bdf5f4d634cbb71899c9afde24573ea1b133213e97cd9cbcb2bc8", "delta": { - "n_added": 1955, - "n_removed": 831, - "n_unchanged": 12390, - "prior_count": 13221, - "current_count": 14345, - "changed_ratio": 0.13628441965841753, + "n_added": 15642, + "n_removed": 13907, + "n_unchanged": 438, + "prior_count": 14345, + "current_count": 16080, + "changed_ratio": 0.9727611940298507, "equivalent_to_full": false, "added_cids_sample": [ - "bafkreia2dan7774wb4g6mp2pvtbzfbgk7kuz2th24khnsfcj2abmbhclhm", - "bafkreia2fhrog33yr27jcgnoaibamggummlmjzyhx3v47ibscwo7oew544", - "bafkreia2htry4ttbiqoa3fh5jjpjduca57uxv26ejqfcsidkvfqsn6u5y4", - "bafkreia2xbuc5ihzavvvorh5f7kmafrlcklsynitmvmqe3cxne3zl5t2v4", - "bafkreia2ymeqelxthes5twox52hwh5wlu4zl3rrspp6fuasjj6hy3mcqya", - "bafkreia2yxuquqemi3wgy6vmxuoi5ld6w3h5fdooheqrxs2o4rwv43sn7y", - "bafkreia323qbn2zp7vgce2isrje34veasnocddni7tk427exhgq42g4com", - "bafkreia344kywwofungpxkkqshy3rnsfvglbrwiwzmlxhiqfsg4m7pmvl4" + "bafkreia225g5darat3tgj4xwm5an7ex3synum3fe5zik3hzoxv5ovpfane", + "bafkreia22hq6sdxhl2mfcujow3rp2hr4emmxlqw26lzazab4rtx2ew2qzm", + "bafkreia22pgduqen2kenqmyf3hcnay5r5xlaxfdsp3vqnpnviujee24nhm", + "bafkreia22pk6ww6ltivz35pa5tfzc6bwvwoadgfl3kh3co6wpxn2w4m2wy", + "bafkreia22wanakezaehqupwo5gcl7np3mfgcltgzl3npetpo5k6n4dl67u", + "bafkreia23na66emyipygzpxlaqhi6h2sgroey6tvsqg4uzkyzofp3ytwh4", + "bafkreia23nywmkzmeowbtncxqc2jln2lr46oob62fnosl5hurfp3msd2ha", + "bafkreia24lfej5rdxwf3lxpc3jlphsl3g7p2sc4ne2knqebqdpbhuuohta" ], "removed_cids_sample": [ - "bafkreia23r2f6cnqy7mnzxeiewevq7ult2nyrcvefubf4dysari4tuthfi", - "bafkreia2efurcdo2edouewlqgvrs2splnmxh53mkbg6mfbmne7rfkz4oou", - "bafkreia2vsd4abkvkfy6afqlzm6w7wrjl5ggncwq375r543edbwxqtw644", - "bafkreia34r5zybzbm3vy6s2k4gpij7rjkxbc7w43awpfqz276rgf4zs2y4", - "bafkreia36kuixce3qljrcmxysbqgo6n7hgjxs743px5u6otpctjg6xgnia", - "bafkreia3hrlbkqx5soy47e2c7y7tmf5vkhmpyxyl4hooqsw6pakxkudkz4", - "bafkreia3lfnyfzbdw5ep7k7t2wilwdnlxu7gvw2uvjfwkvujinqxwriote", - "bafkreia3zhwalqpzgohigcddzkafjkz4by7tp6wpb5nh3tymy77t7wxlfy" + "bafkreia224gpfxi2wj42qt7jjfdjz3dsteace44r5ii2eeygiqxex63xju", + "bafkreia22w4ba4uzyino6sour365nlsr3tk4xub3lj3vq3y35cxssy2gx4", + "bafkreia23tmb6xvdczy7cigkccm6l36ou5453wvga5ye6rden5khsrpsvi", + "bafkreia24vcneznrunocuqppb2u7g4axlpbef3uik4hclylxaejcrfslzm", + "bafkreia25azgvrs62slpwcn22poxq2o46xc3kpf23rd6n6hj7fikvf3mcm", + "bafkreia25utbrnjzwokyljckz6n3p45olvarepnjin53s45tmsd2ldgssy", + "bafkreia262nbzok6n4kpzkhr26brfellzj2dax7oxtvatko2b7jctmb2ee", + "bafkreia26a47v7efigzp3qubdekisaeaiuckte4n567rvdz6uui3ptr6la" ] }, - "reuse_embeddings": true, + "reuse_embeddings": false, "skip_build": false, - "equivalent_to_full": false, + "equivalent_to_full": true, "schema_version": "country-laws-ir-graphrag/v1", "vectors": { - "n_docs": 14345, - "n_reused": 12390, - "n_encoded": 0, - "n_missing": 1955, + "n_docs": 16080, + "n_reused": 0, + "n_encoded": 16080, + "n_missing": 0, "model_name": "thenlper/gte-small", "model_revision": "17e1f347d17fe144873b1201da91788898c639cd", "dimension": 384, - "status": "stub_missing_encoder", + "status": "merged", "device": "cuda", - "device_fallback": false, - "reason": "sentence-transformers/transformers lazy install failed" + "device_fallback": false } }, "sparse": { @@ -366,7 +470,7 @@ "schema_version": "country-laws-ir-graphrag/v1", "bm25": { "bm25": { - "average_document_length": 280.41659114674104, + "average_document_length": 492.495460199005, "b": 0.75, "body_weight": 1.0, "k1": 1.2, @@ -383,34 +487,34 @@ }, "counts": { "bm25_document_chunks": 4, - "bm25_documents": 14345, - "bm25_keyword_shards": 16, - "bm25_posting_rows": 63675, - "bm25_postings": 1546715, - "bm25_terms": 63616, - "bm25_token_instances": 4022576 + "bm25_documents": 16080, + "bm25_keyword_shards": 17, + "bm25_posting_rows": 67613, + "bm25_postings": 2428340, + "bm25_terms": 67529, + "bm25_token_instances": 7919327 }, "indexes": { "bm25_document_chunks": { - "cid": "bafkreic7ye6upp6jqcmg6bqarszuvldxbq77unpagd5h4o3mmntnauu4pq", + "cid": "bafkreicybe4xyr5q7zkzubqqkufdm527rgj7spwwaukl674vsmoxfmjhlm", "relative_path": "indexes/bm25_document_chunks.parquet", "row_count": 4, - "sha256": "5fc13d47bfc980986f06008cb34aac770c3ffa35e030fa7e3b6c6366d0529c7c", - "size_bytes": 5124 + "sha256": "5809397c47b0fe559a0610550a36775f8993f93ed60514bf7f95931d72b1275b", + "size_bytes": 5127 }, "bm25_keyword_shards": { - "cid": "bafkreifcyzn22c4yrrusaw4deze3zit3ql7lcw4xransvf4svmls2x6pfi", + "cid": "bafkreibl3fcvnjb27yyagikj3p554setreqcgitinvx6iblc2ouapheapm", "relative_path": "indexes/bm25_keyword_shards.parquet", - "row_count": 16, - "sha256": "a2c65bad0b988c69205b832649bca27b82feb15b97881b2a9792ab172d5fcf2a", - "size_bytes": 6484 + "row_count": 17, + "sha256": "2bd94556a43afe30032149dbfbde489389202322686d6fe40562d3a8079c807b", + "size_bytes": 6617 } }, "schema_version": "hf-graphrag-bm25-layout/v1" }, "graph": { - "node_count": 20617, - "edge_count": 114760, + "node_count": 23024, + "edge_count": 128640, "adjacency": "data/graph/adjacency/{out,in}/*.parquet" }, "sqlite": false, diff --git a/normalization_report.json b/normalization_report.json index 3385751a242e9e043d5231443a9ba1f040465a33..a7e5948ac2c53529d151b0ca88c3e0fa697f19ab 100644 --- a/normalization_report.json +++ b/normalization_report.json @@ -5,7 +5,7 @@ "articles_sha256": "5b62e48fd10bdf5f4d634cbb71899c9afde24573ea1b133213e97cd9cbcb2bc8", "n_laws_in": 1735, "n_articles_in": 14345, - "unit": "article", + "unit": "law+article", "article_law_coverage": 8.26801152737752, "sparse_article_fallback": false, "drops": { @@ -20,7 +20,7 @@ "duplicate_cid": [] }, "language_breakdown": { - "es": 14345 + "es": 16080 }, "quality_flags": { "articles_table_empty": false, @@ -44,17 +44,124 @@ "laws.eli non-null=1735/1735", "laws.language values=['es']" ], - "n_out": 14345, + "n_out": 16080, "never_invented_legal_text": true, - "n_before_dedupe": 14345, + "n_before_dedupe": 16080, + "n_law_rows": 1735, + "n_child_rows": 14345, + "n_instruments": 1735, "n_dropped_total": 0, "record_type_breakdown": { - "article": 14345 + "article": 14345, + "law": 1735 }, "jurisdiction_breakdown": { - "PE": 14345 + "PE": 16080 }, "snapshot_dates": [ "2026-09-03" - ] + ], + "heading_language_counts": { + "es": 389 + }, + "heading_language_majority": "es", + "document_language_majority": "es", + "verification": { + "schema_version": "country-laws-normalize-verify/v1", + "slug": "", + "admitted": true, + "n_checks": 8, + "n_failed": 0, + "failed_ids": [], + "checks": [ + { + "id": "nonempty_corpus", + "severity": "fail", + "passed": true, + "message": "normalized corpus has rows", + "evidence": { + "n_out": 16080, + "n_dropped": 0 + } + }, + { + "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": 16080, + "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": 207, + "n_bodies": 16080, + "fraction": 0.012873134328358208 + } + }, + { + "id": "parent_laws", + "severity": "warn", + "passed": true, + "message": "parent instruments present (1735 law rows from 1735 source laws)", + "evidence": { + "n_laws_in": 1735, + "n_law_rows": 1735 + } + }, + { + "id": "legal_structure", + "severity": "warn", + "passed": true, + "message": "retrieval units are structured (law+article, coverage=0.89)", + "evidence": { + "unit": "law+article", + "structured_rows": 14345, + "coverage": 0.8921019900497512 + } + }, + { + "id": "heading_language", + "severity": "warn", + "passed": true, + "message": "heading lexicon es vs document language es", + "evidence": { + "document_language": "es", + "heading_language": "es", + "heading_counts": { + "es": 389 + } + } + } + ], + "blocks_graphrag": false + } } diff --git a/normalize.py b/normalize.py index d518f83f1b2fe701b6c1fc5f79335bc6c760a414..50262d25f90dd4e84427bc9ea2d6a8c8901970ba 100644 --- a/normalize.py +++ b/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,8 +12,6 @@ from __future__ import annotations import json import os -import re -import unicodedata from collections import Counter from pathlib import Path from typing import Any @@ -25,8 +24,8 @@ 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", @@ -48,9 +47,7 @@ def _empty_articles() -> pd.DataFrame: 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: @@ -285,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): @@ -373,6 +399,34 @@ def _base_record( } if extra: rec.update(extra) + from .citations import assign_citation, citation_fields + + slug = "" + if source_dataset.startswith("endomorphosis/ipfs_") and source_dataset.endswith("_laws"): + slug = source_dataset.split("ipfs_", 1)[1].removesuffix("_laws") + year = "" + if snapshot_date and len(snapshot_date) >= 4 and snapshot_date[:4].isdigit(): + year = snapshot_date[:4] + extra = extra or {} + rec.update( + citation_fields( + assign_citation( + eli=str(rec.get("eli") or extra.get("eli") or ""), + official_identifier=str( + rec.get("official_identifier") or extra.get("official_identifier") or "" + ), + identifier=str(rec.get("identifier") or extra.get("identifier") or ""), + instrument_title=instrument_title, + article_number=article_number, + section_number=str(extra.get("section_number") or ""), + record_type=record_type, + jurisdiction=jurisdiction, + country=str(extra.get("country") or ""), + slug=slug, + year=year, + ) + ) + ) rec["entry_cid"] = _entry_cid(rec) rec["title_length"] = len(title_for_bm25) rec["body_length"] = len(body) @@ -433,11 +487,62 @@ def build_corpus( entries: list[dict[str, Any]] = [] + def _append_law_row(instrument_id: str, parent: dict[str, Any]) -> None: + 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) + return + meta = parent["metadata"] + 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=articles_empty, + 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"] + ), + }, + ) + ) + if sparse_fallback: report["schema_surprises"].append( f"article coverage {article_law_coverage:.4f} < 0.10 of laws; falling back to law-level units" ) + for instrument_id, parent in law_map.items(): + _append_law_row(instrument_id, parent) + if use_articles: for _, row in articles.iterrows(): source_id = _row_get(row, "id") @@ -489,6 +594,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"] + ), }, ) ) @@ -496,44 +604,50 @@ def build_corpus( 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"] - 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": "", - }, - ) - ) + 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), + }, + ) + ) entries.sort( key=lambda r: ( @@ -564,6 +678,20 @@ def build_corpus( raise SchemaError("Duplicate entry_cid remained after dedupe") report["n_before_dedupe"] = n_before report["n_out"] = int(len(df)) + if not df.empty and "record_type" in df.columns: + n_law_rows = int((df["record_type"] == "law").sum()) + n_child_rows = int(df["record_type"].isin(["article", "section"]).sum()) + report["n_law_rows"] = n_law_rows + report["n_child_rows"] = n_child_rows + report["n_instruments"] = int(df["instrument_id"].nunique()) if "instrument_id" in df.columns else n_law_rows + if n_law_rows and n_child_rows: + report["unit"] = ( + "law+structured" if report.get("unit") == "structured" else "law+article" + ) + elif n_law_rows: + report["unit"] = "law" + elif n_child_rows: + report["unit"] = "article" report["n_dropped_total"] = ( report["drops"]["empty_body"] + report["drops"]["missing_instrument"] @@ -607,5 +735,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/query.py b/query.py index 9cd3a1da6f2ac29b2287609ec1bc797fd55c4774..d1f4db567a8944a31bc19a28c6fb6b78aed632f8 100644 --- a/query.py +++ b/query.py @@ -158,6 +158,11 @@ class Release: hits.sort(key=lambda r: (-(r["score"] or 0), r["neighbor_cid"])) return hits[:limit] + def cite(self, citation: str, cite_format: str = "any", limit: int = 25) -> list[dict]: + from .duckdb_store import cite_search + + return cite_search(self.root, citation, cite_format=cite_format, limit=limit) + def _print(rows: list[dict]) -> None: print(json.dumps(rows, indent=2, ensure_ascii=False)) @@ -189,6 +194,16 @@ def main(argv: list[str] | None = None) -> int: ) p_n.add_argument("--limit", type=int, default=25) + p_cite = sub.add_parser("cite") + p_cite.add_argument("citation") + p_cite.add_argument( + "--format", + dest="cite_format", + default="any", + choices=["any", "bluebook", "official"], + ) + p_cite.add_argument("--limit", type=int, default=25) + args = ap.parse_args(argv) rel = Release(Path(args.local_dir)) if args.cmd == "bm25": @@ -197,6 +212,8 @@ def main(argv: list[str] | None = None) -> int: _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)) + elif args.cmd == "cite": + _print(rel.cite(args.citation, cite_format=args.cite_format, limit=args.limit)) return 0 diff --git a/reports/normalization.json b/reports/normalization.json index 3385751a242e9e043d5231443a9ba1f040465a33..a7e5948ac2c53529d151b0ca88c3e0fa697f19ab 100644 --- a/reports/normalization.json +++ b/reports/normalization.json @@ -5,7 +5,7 @@ "articles_sha256": "5b62e48fd10bdf5f4d634cbb71899c9afde24573ea1b133213e97cd9cbcb2bc8", "n_laws_in": 1735, "n_articles_in": 14345, - "unit": "article", + "unit": "law+article", "article_law_coverage": 8.26801152737752, "sparse_article_fallback": false, "drops": { @@ -20,7 +20,7 @@ "duplicate_cid": [] }, "language_breakdown": { - "es": 14345 + "es": 16080 }, "quality_flags": { "articles_table_empty": false, @@ -44,17 +44,124 @@ "laws.eli non-null=1735/1735", "laws.language values=['es']" ], - "n_out": 14345, + "n_out": 16080, "never_invented_legal_text": true, - "n_before_dedupe": 14345, + "n_before_dedupe": 16080, + "n_law_rows": 1735, + "n_child_rows": 14345, + "n_instruments": 1735, "n_dropped_total": 0, "record_type_breakdown": { - "article": 14345 + "article": 14345, + "law": 1735 }, "jurisdiction_breakdown": { - "PE": 14345 + "PE": 16080 }, "snapshot_dates": [ "2026-09-03" - ] + ], + "heading_language_counts": { + "es": 389 + }, + "heading_language_majority": "es", + "document_language_majority": "es", + "verification": { + "schema_version": "country-laws-normalize-verify/v1", + "slug": "", + "admitted": true, + "n_checks": 8, + "n_failed": 0, + "failed_ids": [], + "checks": [ + { + "id": "nonempty_corpus", + "severity": "fail", + "passed": true, + "message": "normalized corpus has rows", + "evidence": { + "n_out": 16080, + "n_dropped": 0 + } + }, + { + "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": 16080, + "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": 207, + "n_bodies": 16080, + "fraction": 0.012873134328358208 + } + }, + { + "id": "parent_laws", + "severity": "warn", + "passed": true, + "message": "parent instruments present (1735 law rows from 1735 source laws)", + "evidence": { + "n_laws_in": 1735, + "n_law_rows": 1735 + } + }, + { + "id": "legal_structure", + "severity": "warn", + "passed": true, + "message": "retrieval units are structured (law+article, coverage=0.89)", + "evidence": { + "unit": "law+article", + "structured_rows": 14345, + "coverage": 0.8921019900497512 + } + }, + { + "id": "heading_language", + "severity": "warn", + "passed": true, + "message": "heading lexicon es vs document language es", + "evidence": { + "document_language": "es", + "heading_language": "es", + "heading_counts": { + "es": 389 + } + } + } + ], + "blocks_graphrag": false + } }