#!/usr/bin/env python3 """Thin-client query for country-laws IR releases (local dir).""" from __future__ import annotations import argparse import json from collections import defaultdict from pathlib import Path import numpy as np import pandas as pd K1 = 1.2 B = 0.75 TITLE_WEIGHT = 5.0 BODY_WEIGHT = 1.0 MAX_QUERY_TERMS = 64 def tokenize(text: str) -> list[str]: import re import unicodedata if not text: return [] nfkd = unicodedata.normalize("NFKD", text) folded = "".join(ch for ch in nfkd if not unicodedata.combining(ch)).lower() return re.findall(r"[0-9A-Za-z]+", folded) class Release: def __init__(self, root: Path): self.root = Path(root) self.manifest = json.loads((self.root / "manifest.json").read_text(encoding="utf-8")) def _read(self, rel: str) -> pd.DataFrame: path = self.root / rel if path.is_dir(): files = sorted(path.glob("*.parquet")) return pd.concat([pd.read_parquet(f) for f in files], ignore_index=True) if files else pd.DataFrame() return pd.read_parquet(path) def bm25(self, query: str, top_k: int = 10) -> list[dict]: try: from .duckdb_store import bm25_search return bm25_search(self.root, query, top_k=top_k) except Exception: pass q_terms = tokenize(query)[:MAX_QUERY_TERMS] if not q_terms: return [] shards = pd.read_parquet(self.root / "indexes" / "bm25_keyword_shards.parquet") needed = set() for term in q_terms: hit = shards[(shards["first_key"] <= term) & (shards["last_key"] >= term)] if hit.empty: hit = shards for rel in hit["relative_path"].tolist(): needed.add(rel) postings = pd.concat( [pd.read_parquet(self.root / rel) for rel in sorted(needed)], ignore_index=True, ) postings = postings[postings["term"].isin(q_terms)] docs = self._read("data/bm25/documents") avgdl = float(self.manifest["bm25"]["average_document_length"]) or 1.0 scores: dict[int, float] = defaultdict(float) for rec in postings.itertuples(index=False): idf = float(rec.idf) for di, ttf, btf, dl in zip( rec.document_indices, rec.title_frequencies, rec.body_frequencies, rec.document_lengths ): tf = TITLE_WEIGHT * int(ttf) + BODY_WEIGHT * int(btf) denom = tf + K1 * (1.0 - B + B * (int(dl) / avgdl)) if denom: scores[int(di)] += idf * (tf * (K1 + 1.0)) / denom ranked = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)[:top_k] by_idx = docs.set_index("document_index") out = [] for di, score in ranked: row = by_idx.loc[di] out.append( { "document_index": int(di), "entry_cid": row["entry_cid"], "title": row["title"], "record_type": row["record_type"], "instrument_id": row.get("instrument_id", row.get("law_id", "")), "law_cid": row.get("law_cid", ""), "score": float(score), } ) return out def vector(self, query: str, top_k: int = 10, candidate_centroids: int = 4, device: str = "cpu") -> list[dict]: status = (self.manifest.get("vector") or {}).get("status") if status == "stub": return [{"error": "vectors are stubbed", "reason": self.manifest["vector"].get("stub_reason")}] from sentence_transformers import SentenceTransformer model = SentenceTransformer(self.manifest["vector"]["model_name"], device=device) q = model.encode([query], normalize_embeddings=True, convert_to_numpy=True)[0].astype(np.float32) meta = pd.read_parquet(self.root / "indexes" / "vector_chunks.parquet") cents = np.stack(meta["centroid"].map(lambda c: np.asarray(c, dtype=np.float32)).to_numpy()) sims = cents @ q order = np.argsort(-sims)[: max(1, candidate_centroids)] shards = meta.iloc[order] frames = [pd.read_parquet(self.root / rel) for rel in shards["relative_path"].tolist()] vecs = pd.concat(frames, ignore_index=True) if "embedding" not in vecs.columns or vecs["embedding"].isna().all(): return [{"error": "vector shard missing embeddings"}] emb = np.stack(vecs["embedding"].map(lambda e: np.asarray(e, dtype=np.float32)).to_numpy()) scores = emb @ q top = np.argsort(-scores)[:top_k] out = [] for i in top: row = vecs.iloc[int(i)] out.append( { "document_index": int(row["document_index"]), "entry_cid": row["entry_cid"], "title": row["title"], "record_type": row["record_type"], "instrument_id": row.get("instrument_id", row.get("law_id", "")), "score": float(scores[int(i)]), } ) return out def neighbors(self, node_cid: str, direction: str = "both", limit: int = 25) -> list[dict]: try: from .duckdb_store import graph_neighbors return graph_neighbors(self.root, node_cid, direction=direction, limit=limit) except Exception: pass dirs = ["incoming", "outgoing"] if direction == "both" else [direction] hits = [] for d in dirs: path = self.root / "data" / "graph" / "adjacency" / d files = sorted(path.glob("*.parquet")) for f in files: df = pd.read_parquet(f) sub = df[df["node_cid"] == node_cid] for rec in sub.itertuples(index=False): for i, neigh in enumerate(rec.neighbor_cids): hits.append( { "direction": d, "node_cid": node_cid, "neighbor_cid": neigh, "edge_type": rec.edge_types[i] if i < len(rec.edge_types) else "", "score": rec.scores[i] if rec.scores is not None and i < len(rec.scores) else None, } ) hits.sort(key=lambda r: (-(r["score"] or 0), r["neighbor_cid"])) return hits[:limit] def 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)) def main(argv: list[str] | None = None) -> int: ap = argparse.ArgumentParser(description="Query a country-laws IR release") ap.add_argument("--local-dir", required=True, help="Path to local release root") sub = ap.add_subparsers(dest="cmd", required=True) p_bm = sub.add_parser("bm25") p_bm.add_argument("query") p_bm.add_argument("--top-k", type=int, default=10) p_vec = sub.add_parser("vector") p_vec.add_argument("query") p_vec.add_argument("--top-k", type=int, default=10) p_vec.add_argument("--candidate-centroids", type=int, default=4) p_vec.add_argument("--device", default="cuda") p_g = sub.add_parser("graph") g_sub = p_g.add_subparsers(dest="graph_cmd", required=True) p_n = g_sub.add_parser("neighbors") p_n.add_argument("node_cid") p_n.add_argument( "--direction", default="both", choices=["both", "in", "out", "incoming", "outgoing"], ) p_n.add_argument("--limit", type=int, default=25) 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": _print(rel.bm25(args.query, top_k=args.top_k)) elif args.cmd == "vector": _print(rel.vector(args.query, top_k=args.top_k, candidate_centroids=args.candidate_centroids, device=args.device)) elif args.cmd == "graph" and args.graph_cmd == "neighbors": _print(rel.neighbors(args.node_cid, direction=args.direction, limit=args.limit)) elif args.cmd == "cite": _print(rel.cite(args.citation, cite_format=args.cite_format, limit=args.limit)) return 0 if __name__ == "__main__": raise SystemExit(main())