"""Assemble the final package: merged tables, JSONL, splits, docs, checksums, zip.""" from __future__ import annotations import gzip import json import zipfile from pathlib import Path import pyarrow as pa import pyarrow.parquet as pq from common import ( ROOT, ensure_dirs, get_logger, human_bytes, load_config, p, read_json, sha256_file, utc_now, write_json, ) from schema import ( WORK_AUTHORS, WORK_INSTITUTIONS, WORK_TOPICS, WORKS_FULL, ) import docs RELATION_MERGES = { "work_authors": (WORK_AUTHORS, "data/work_authors.parquet"), "work_institutions": (WORK_INSTITUTIONS, "data/work_institutions.parquet"), "work_topics": (WORK_TOPICS, "data/work_topics.parquet"), } def merge_parquet(files: list[Path], out_path: Path, schema: pa.Schema) -> int: out_path.parent.mkdir(parents=True, exist_ok=True) writer = None rows = 0 try: for f in files: pf = pq.ParquetFile(f) for batch in pf.iter_batches(batch_size=100000): tbl = pa.Table.from_batches([batch]) tbl = tbl.select([c for c in schema.names]) tbl = tbl.cast(schema) if writer is None: writer = pq.ParquetWriter(out_path, schema, compression="zstd") writer.write_table(tbl) rows += tbl.num_rows finally: if writer is not None: writer.close() return rows def _iter_rows(parquet_path: Path): pf = pq.ParquetFile(parquet_path) for batch in pf.iter_batches(batch_size=5000): d = batch.to_pydict() keys = list(d.keys()) for i in range(batch.num_rows): yield {k: d[k][i] for k in keys} def _write_jsonl_and_splits(works_path: Path, data_dir: Path, splits_cfg: dict, write_full: bool = True): """Single streaming pass: optional full JSONL + chronological splits.""" import os full_tmp = data_dir / "works.jsonl.gz.tmp" names = ["train", "validation", "test"] split_tmps = {n: data_dir / f"biomedical_works_{n}.jsonl.gz.tmp" for n in names} handles = {n: gzip.open(p, "wt", encoding="utf-8") for n, p in split_tmps.items()} counts = {n: 0 for n in names} n_full = 0 def route(y): if y is None: return None if y <= splits_cfg["train_max_year"]: return "train" if y in splits_cfg["validation_years"]: return "validation" if y >= splits_cfg["test_min_year"]: return "test" return None full = gzip.open(full_tmp, "wt", encoding="utf-8") if write_full else None try: for row in _iter_rows(works_path): line = json.dumps(row, ensure_ascii=False, default=str) if full is not None: full.write(line); full.write("\n") n_full += 1 name = route(row.get("publication_year")) if name: handles[name].write(line); handles[name].write("\n"); counts[name] += 1 finally: if full is not None: full.close() for h in handles.values(): h.close() if write_full: os.replace(full_tmp, data_dir / "works.jsonl.gz") elif full_tmp.exists(): os.remove(full_tmp) for n in names: os.replace(split_tmps[n], data_dir / f"biomedical_works_{n}.jsonl.gz") return n_full, counts def build_tables(cfg: dict) -> dict: logger = get_logger("diversa.package", p(cfg, "logs") / "pipeline.log") parts = p(cfg, "parts") data_dir = p(cfg, "data") data_dir.mkdir(parents=True, exist_ok=True) works_files = sorted((parts / "works_full").glob("*.parquet")) works_out = data_dir / "works.parquet" if works_files: logger.info("merging %d works parts -> data/works.parquet", len(works_files)) n_works = merge_parquet(works_files, works_out, WORKS_FULL) elif works_out.exists(): n_works = pq.ParquetFile(works_out).metadata.num_rows logger.info("works parts already merged; reusing data/works.parquet (%s rows)", f"{n_works:,}") else: raise SystemExit("no works parts and no data/works.parquet; run derive_features first") for name, (schema, rel) in RELATION_MERGES.items(): files = sorted((parts / name).glob("*.parquet")) if files: logger.info("merging %d %s parts", len(files), name) merge_parquet(files, ROOT / rel, schema) if cfg["storage"].get("free_parts_after_merge", True): import shutil for d in ("works", "works_full", "work_authors", "work_institutions", "work_topics"): shutil.rmtree(parts / d, ignore_errors=True) logger.info("freed staging parts after merge") write_full = cfg.get("package", {}).get("write_full_jsonl", True) if write_full: import shutil est = n_works * 1300 if shutil.disk_usage(ROOT).free < est * 2.2: logger.warning("low disk: skipping the redundant full works.jsonl.gz " "(the train/val/test splits still contain every row)") write_full = False logger.info("writing chronological splits%s (streaming)", " + full works.jsonl.gz" if write_full else "") n_jsonl, split_counts = _write_jsonl_and_splits( data_dir / "works.parquet", data_dir, cfg["splits"], write_full=write_full) if not write_full: n_jsonl = None for name, n in split_counts.items(): logger.info("split %-11s %s rows", name, f"{n:,}") return {"works": n_works, "works_jsonl": n_jsonl, "splits": split_counts} def write_metadata(cfg: dict) -> dict: data_dir = p(cfg, "data") meta_dir = p(cfg, "metadata") anchors = [ROOT / rel for rel in [ "data/works.parquet", "data/work_authors.parquet", "data/work_institutions.parquet", "data/work_topics.parquet", "data/authors.parquet", "data/institutions.parquet", "data/topics.parquet", "data/sources.parquet", "data/citation_edges.parquet", "analytics/topic_year_counts.parquet", "analytics/topic_growth.parquet", "analytics/country_year_counts.parquet", "analytics/country_collaboration.parquet", "analytics/institution_activity.parquet", ]] schema_doc = {} for rel in anchors: if rel.exists(): schema_doc[str(rel.relative_to(ROOT))] = { f.name: str(f.type) for f in pq.ParquetFile(rel).schema_arrow } write_json(meta_dir / "schema.json", schema_doc) build_info = { "project": cfg["project"]["name"], "version": cfg["project"]["version"], "build_timestamp": utc_now(), "python": __import__("sys").version.split()[0], "pipeline_modules": ["discover_taxonomy", "collect", "normalize", "derive_features", "build_relations", "analyze", "validate", "package"], "config": {k: v for k, v in cfg.items() if k != "_root"}, "scope": cfg["scope"], "source": {**cfg["source"], "api_key": None}, } write_json(meta_dir / "build_info.json", build_info) # file inventory files = [] total = 0 for base in ("data", "analytics", "metadata"): for f in sorted((ROOT / base).rglob("*")): if f.is_file() and f.suffix != ".tmp": files.append(str(f.relative_to(ROOT))) for f in ["README.md", "DATA_DICTIONARY.md", "METHODOLOGY.md", "PROVENANCE.md", "LICENSE_AND_RIGHTS.md", "QUALITY_REPORT.md", "config.yaml", "requirements.txt", "run-all.py"]: if (ROOT / f).exists(): files.append(f) return {"files": files, "count": len(files)} def write_docs(cfg: dict) -> dict: stats = read_json(p(cfg, "metadata") / "dataset_statistics.json", default={}) or {} validation = read_json(p(cfg, "metadata") / "validation_report.json", default={}) or {} source_queries = read_json(p(cfg, "metadata") / "source_queries.json", default=[]) or [] norm_stats = read_json(p(cfg, "checkpoints") / "normalize_stats.json", default={}) or {} derive_stats = read_json(p(cfg, "checkpoints") / "derive_stats.json", default={}) or {} manifest_path = p(cfg, "metadata") / "manifest.json" manifest = read_json(manifest_path, default={}) or {} files = manifest.get("files", []) text = { "README.md": docs.readme(cfg, stats, manifest), "DATA_DICTIONARY.md": docs.data_dictionary(cfg, stats), "METHODOLOGY.md": docs.methodology(cfg), "PROVENANCE.md": docs.provenance(cfg, source_queries, stats, manifest), "LICENSE_AND_RIGHTS.md": docs.license_and_rights(cfg), "QUALITY_REPORT.md": docs.quality_report(cfg, validation, stats, norm_stats, derive_stats, files), } for name, content in text.items(): (ROOT / name).write_text(content, encoding="utf-8") return {"docs": list(text.keys())} def finalize(cfg: dict) -> dict: logger = get_logger("diversa.package", p(cfg, "logs") / "pipeline.log") ROOT.mkdir(parents=True, exist_ok=True) inventory = write_metadata(cfg) provisional = { "name": cfg["project"]["name"], "title": cfg["project"]["title"], "version": cfg["project"]["version"], "build_timestamp": utc_now(), "source": "OpenAlex (https://openalex.org), CC0 1.0", "scope": cfg["scope"], "splits": cfg["splits"], "files": inventory["files"], "package_size_bytes": 0, } write_json(p(cfg, "metadata") / "manifest.json", provisional) write_docs(cfg) # checksums over every delivered file (including docs), excluding the archive docs_files = [f for f in ["README.md", "DATA_DICTIONARY.md", "METHODOLOGY.md", "PROVENANCE.md", "LICENSE_AND_RIGHTS.md", "QUALITY_REPORT.md"] if (ROOT / f).exists()] checksums = [] total = 0 file_entries = [] self_referential = {"metadata/manifest.json", "metadata/package_report.json", "checksums.sha256"} for rel in sorted(set(inventory["files"]) | set(docs_files)): path = ROOT / rel if not path.exists() or rel in self_referential: continue digest = sha256_file(path) size = path.stat().st_size total += size checksums.append(f"{digest} {rel}") file_entries.append({"path": rel, "bytes": size, "sha256": digest}) (ROOT / "checksums.sha256").write_text("\n".join(checksums) + "\n", encoding="utf-8") manifest = dict(provisional) manifest["files"] = [f["path"] for f in file_entries] manifest["file_sizes"] = {f["path"]: f["bytes"] for f in file_entries} manifest["package_size_bytes"] = total manifest["package_size_human"] = human_bytes(total) write_json(p(cfg, "metadata") / "manifest.json", manifest) logger.info("writing archive") zip_path = ROOT.parent / f"{cfg['project']['name']}.zip" if zip_path.exists(): zip_path.unlink() with zipfile.ZipFile(zip_path, "w", allowZip64=True) as zf: for rel in sorted(set(inventory["files"]) | {"checksums.sha256", "README.md", "DATA_DICTIONARY.md", "METHODOLOGY.md", "PROVENANCE.md", "LICENSE_AND_RIGHTS.md", "QUALITY_REPORT.md"}): path = ROOT / rel if not path.exists(): continue compress = zipfile.ZIP_DEFLATED if path.suffix in (".md", ".json", ".yaml", ".txt", ".py", ".sha256") else zipfile.ZIP_STORED zf.write(path, arcname=f"{cfg['project']['name']}/{rel}") zip_size = zip_path.stat().st_size logger.info("archive: %s", zip_path) result = { "package_dir": str(ROOT), "zip_path": str(zip_path), "zip_size_bytes": zip_size, "zip_size_human": human_bytes(zip_size), "package_size_bytes": total, "package_size_human": human_bytes(total), "files": len(file_entries), "manifest": manifest, } write_json(p(cfg, "metadata") / "package_report.json", {k: v for k, v in result.items() if k != "manifest"}) return result def run(cfg: dict | None = None) -> dict: cfg = cfg or load_config() ensure_dirs(cfg) tables = build_tables(cfg) import validate validate.run(cfg) result = finalize(cfg) result["tables"] = tables return result if __name__ == "__main__": run()