"""Property graph: entry nodes, facet nodes, BM25_NEIGHBOR_OF k=8, ARTICLE_OF, ELI.""" from __future__ import annotations from collections import defaultdict from typing import Any import pandas as pd from . import EDGE_IDENTITY_SCHEMA, FACET_IDENTITY_SCHEMA, SCHEMA_VERSION from .cidutil import cid_of_json # Facet kinds requested by the SkillCenter-style country-laws graph: # jurisdiction, language, instrument/law, source, status. FACET_FIELDS = ( ("jurisdiction", "HAS_JURISDICTION", "jurisdiction"), ("language", "HAS_LANGUAGE", "language"), ("instrument", "HAS_INSTRUMENT", "instrument_id"), ("source", "HAS_SOURCE", "source_type"), ("status", "HAS_STATUS", "law_status"), ) ADJ_POINTERS_PER_ROW = 4096 ADJ_POINTERS_PER_SHARD = 8192 def _facet_cid(kind: str, value: str) -> str: """CIDv1 raw sha2-256 of sorted JSON {kind, schema, value}.""" return cid_of_json( { "kind": kind, "schema": FACET_IDENTITY_SCHEMA, "value": value, } ) def _edge_cid(source: str, edge_type: str, target: str) -> str: return cid_of_json( { "edge_type": edge_type, "schema": EDGE_IDENTITY_SCHEMA, "source": source, "target": target, } ) def build_graph( corpus: pd.DataFrame, neighbors: list[list[tuple]], ) -> dict[str, Any]: nodes: list[dict[str, Any]] = [] edges: list[dict[str, Any]] = [] seen_facets: set[str] = set() cid_by_idx = corpus["entry_cid"].tolist() # Law identity nodes (targets of ARTICLE_OF when the parent is not a corpus entry). law_nodes: dict[str, dict[str, Any]] = {} entry_by_instrument: dict[str, str] = {} for rec in corpus.itertuples(index=False): law_cid = str(getattr(rec, "law_cid", "") or "") instrument_id = str(getattr(rec, "instrument_id", "") or "") if getattr(rec, "record_type", "") == "law" and instrument_id and rec.entry_cid: entry_by_instrument.setdefault(instrument_id, rec.entry_cid) if not law_cid or law_cid in law_nodes: continue law_nodes[law_cid] = { "node_cid": law_cid, "node_type": "law", "entry_cid": "", "label": str(getattr(rec, "instrument_title", None) or instrument_id).replace("\x00", ""), "properties_json": _json( { "instrument_id": instrument_id, "instrument_title": str(getattr(rec, "instrument_title", "") or ""), "jurisdiction": str(getattr(rec, "jurisdiction", "") or ""), "language": str(getattr(rec, "language", "") or ""), "law_cid": law_cid, } ), "schema_version": SCHEMA_VERSION, } for law_node in law_nodes.values(): nodes.append(law_node) for rec in corpus.itertuples(index=False): node_type = "law_entry" if rec.record_type == "law" else "article" title = getattr(rec, "title", None) or getattr(rec, "instrument_title", None) or rec.source_id nodes.append( { "node_cid": rec.entry_cid, "node_type": node_type, "entry_cid": rec.entry_cid, "label": str(title or "").replace("\x00", ""), "properties_json": _props_tuple(rec), "schema_version": SCHEMA_VERSION, } ) src = rec.entry_cid row_map = rec._asdict() if hasattr(rec, "_asdict") else {} for kind, edge_type, col in FACET_FIELDS: value = str(row_map.get(col) or "").strip() if not value: continue fc = _facet_cid(kind, value) if fc not in seen_facets: seen_facets.add(fc) nodes.append( { "node_cid": fc, "node_type": f"facet_{kind}", "entry_cid": "", "label": f"{kind}:{value}".replace("\x00", ""), "properties_json": _json({"kind": kind, "value": value}), "schema_version": SCHEMA_VERSION, } ) edges.append(_edge(src, edge_type, fc, "facet", 1.0, {"facet": kind, "value": value})) # ELI / identifier links — only values present in the source, never invented. eli = str(row_map.get("eli") or "").strip() if eli: fc = _facet_cid("eli", eli) if fc not in seen_facets: seen_facets.add(fc) nodes.append( { "node_cid": fc, "node_type": "facet_eli", "entry_cid": "", "label": f"eli:{eli}", "properties_json": _json({"kind": "eli", "value": eli}), "schema_version": SCHEMA_VERSION, } ) edges.append(_edge(src, "IDENTIFIED_BY_ELI", fc, "identifier", 1.0, {"eli": eli})) ident = str(row_map.get("official_identifier") or row_map.get("identifier") or "").strip() if ident and ident != eli: fc = _facet_cid("identifier", ident) if fc not in seen_facets: seen_facets.add(fc) nodes.append( { "node_cid": fc, "node_type": "facet_identifier", "entry_cid": "", "label": f"identifier:{ident}", "properties_json": _json({"kind": "identifier", "value": ident}), "schema_version": SCHEMA_VERSION, } ) edges.append( _edge(src, "IDENTIFIED_BY", fc, "identifier", 1.0, {"identifier": ident}) ) law_cid = str(row_map.get("law_cid") or "") instrument_id = str(row_map.get("instrument_id") or "") if rec.record_type in {"article", "section"}: parent = entry_by_instrument.get(instrument_id) or law_cid if parent and parent != rec.entry_cid: edges.append( _edge( rec.entry_cid, "ARTICLE_OF", parent, "structural", 1.0, { "instrument_id": instrument_id, "article_number": row_map.get("article_number"), }, ) ) elif law_cid and rec.entry_cid != law_cid: # Law-level corpus unit still points at its instrument identity node. edges.append( _edge( rec.entry_cid, "HAS_INSTRUMENT", law_cid, "structural", 1.0, {"instrument_id": instrument_id}, ) ) for i, neigh in enumerate(neighbors): src = cid_by_idx[i] for item in neigh: if len(item) == 3: j, score, terms = item else: j, score = item[0], item[1] terms = [] tgt = cid_by_idx[int(j)] edges.append( _edge( src, "BM25_NEIGHBOR_OF", tgt, "bm25-okapi", float(score), {"k": 8, "neighbor_index": int(j)}, matched_terms=list(terms), ) ) nodes_df = pd.DataFrame(nodes).drop_duplicates("node_cid").reset_index(drop=True) nodes_df = nodes_df.sort_values(["node_type", "node_cid"]).reset_index(drop=True) edges_df = pd.DataFrame(edges) if not edges_df.empty: edges_df = edges_df.drop_duplicates("edge_cid").reset_index(drop=True) edges_df = edges_df.sort_values(["edge_type", "source_cid", "target_cid"]).reset_index(drop=True) node_type = {r["node_cid"]: r["node_type"] for r in nodes_df.to_dict("records")} incoming, outgoing = _adjacency(edges_df, node_type) return { "nodes": nodes_df, "edges": edges_df, "incoming": incoming, "outgoing": outgoing, "stats": { "n_nodes": int(len(nodes_df)), "n_edges": int(len(edges_df)), "n_doc_nodes": int(nodes_df["node_type"].isin(["law_entry", "article", "law"]).sum()), "n_facet_nodes": int(nodes_df["node_type"].astype(str).str.startswith("facet_").sum()), "edge_types": sorted(edges_df["edge_type"].unique().tolist()) if not edges_df.empty else [], }, } def _json(obj: dict) -> str: import json return json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(",", ":")) def _props_tuple(rec: Any) -> str: keys = [ "record_type", "instrument_id", "instrument_title", "law_cid", "article_number", "article_title", "jurisdiction", "language", "source_url", "snapshot_date", "coverage", "license", "collector", "source_id", "eli", "law_status", "source_type", ] d = rec._asdict() if hasattr(rec, "_asdict") else {} out = {} for k in keys: v = d.get(k, "") if v is None or (isinstance(v, float) and pd.isna(v)): v = "" out[k] = str(v) return _json(out) def _edge( src: str, etype: str, tgt: str, method: str, score: float, props: dict, matched_terms: list[str] | None = None, ) -> dict[str, Any]: import json terms = matched_terms or [] return { "edge_cid": _edge_cid(src, etype, tgt), "edge_type": etype, "source_cid": src, "target_cid": tgt, "retrieval_method": method, "score": float(score), "query_terms_json": json.dumps(terms, ensure_ascii=False, separators=(",", ":")), "matched_terms": terms, "properties_json": _json({k: v for k, v in props.items() if v is not None}), "schema_version": SCHEMA_VERSION, } def _adjacency(edges: pd.DataFrame, node_type: dict[str, str]) -> tuple[pd.DataFrame, pd.DataFrame]: out_map: dict[str, list[tuple[float, str, str, str]]] = defaultdict(list) in_map: dict[str, list[tuple[float, str, str, str]]] = defaultdict(list) if edges is None or edges.empty: return pd.DataFrame(), pd.DataFrame() for rec in edges.itertuples(index=False): score = float(rec.score) if rec.score == rec.score else float("-inf") out_map[rec.source_cid].append((score, rec.target_cid, rec.edge_type, rec.edge_cid)) in_map[rec.target_cid].append((score, rec.source_cid, rec.edge_type, rec.edge_cid)) def pages(mapping: dict[str, list], direction: str) -> pd.DataFrame: rows = [] for node, items in mapping.items(): items = sorted(items, key=lambda t: (-t[0] if t[0] == t[0] else float("inf"), t[1])) total = len(items) page_size = ADJ_POINTERS_PER_ROW n_pages = max(1, (total + page_size - 1) // page_size) for p in range(n_pages): chunk = items[p * page_size : (p + 1) * page_size] rows.append( { "direction": direction, "node_cid": node, "page_index": p, "page_count": n_pages, "neighbor_count": len(chunk), "total_neighbor_count": total, "neighbor_cids": [t[1] for t in chunk], "neighbor_node_types": [node_type.get(t[1], "") for t in chunk], "edge_types": [t[2] for t in chunk], "edge_cids": [t[3] for t in chunk], "retrieval_methods": ["graph"] * len(chunk), "scores": [t[0] if t[0] != float("-inf") else None for t in chunk], "schema_version": SCHEMA_VERSION, } ) if not rows: return pd.DataFrame() return pd.DataFrame(rows).sort_values(["node_cid", "page_index"]).reset_index(drop=True) return pages(in_map, "incoming"), pages(out_map, "outgoing")