| """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) |
|
|
| |
| 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) |
|
|
| |
| 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() |
|
|
