code/prepare_huggingface_dataset.py

#!/usr/bin/env python3
"""Prepare the PATSTAT AI master dataset for a private Hugging Face repository."""

from __future__ import annotations

import argparse
import csv
import gzip
import hashlib
import json
import shutil
from pathlib import Path

import pyarrow as pa
import pyarrow.csv as pacsv
import pyarrow.parquet as pq


PERIODS = (
    (0, 1950, "before_1950"),
    (1950, 1959, "1950s"),
    (1960, 1969, "1960s"),
    (1970, 1979, "1970s"),
    (1980, 1989, "1980s"),
    (1990, 1999, "1990s"),
    (2000, 2009, "2000s"),
    (2010, 2019, "2010s"),
    (2020, 2026, "2020_2026"),
)


def period_label(year: int | None) -> str:
    if year is None:
        return "unknown_year"
    for start, end, label in PERIODS:
        if start <= year <= end:
            return label
    return "after_2026"


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        for block in iter(lambda: stream.read(8 * 1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def copy_supporting_files(source_dir: Path, output_dir: Path) -> None:
    mappings = {
        "HUGGINGFACE_README.md": "README.md",
        "PATSTAT_AI_COMPLETE_MASTER_TECHNICAL_REPORT.pdf": "documentation/technical_report.pdf",
        "PATSTAT_AI_COMPLETE_MASTER_TECHNICAL_REPORT.tex": "documentation/technical_report.tex",
        "DATASET_REPORT.md": "documentation/dataset_report.md",
        "final_master_column_descriptive_statistics.csv": "metadata/column_descriptive_statistics.csv",
        "ipc_cpc_missingness_by_year.csv": "metadata/ipc_cpc_missingness_by_year.csv",
        "integration_report.json": "metadata/integration_report.json",
        "coalesced_fields_report.json": "metadata/coalesced_fields_report.json",
        "ipc_cpc_backfill_1950_2026_report.json": "metadata/ipc_cpc_backfill_report.json",
        "build_complete_master_20260712.py": "code/build_complete_master.py",
        "finalize_legacy_country_flags.py": "code/finalize_legacy_country_flags.py",
        "coalesce_new_source_fields.py": "code/coalesce_new_source_fields.py",
        "apply_ipc_cpc_backfill_1990_2022.py": "code/apply_ipc_cpc_backfill.py",
        "prepare_huggingface_dataset.py": "code/prepare_huggingface_dataset.py",
    }
    for source_name, target_name in mappings.items():
        source = source_dir / source_name
        if source.exists():
            target = output_dir / target_name
            target.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(source, target)


def build_dataset(source: Path, output_dir: Path) -> dict:
    data_dir = output_dir / "data" / "by_priority_period"
    if data_dir.exists():
        shutil.rmtree(data_dir)
    data_dir.mkdir(parents=True, exist_ok=True)
    writers: dict[str, pq.ParquetWriter] = {}
    counts: dict[str, int] = {}
    schema: pa.Schema | None = None

    with gzip.open(source, "rt", encoding="utf-8-sig", newline="") as stream:
        columns = next(csv.reader(stream))
    read_options = pacsv.ReadOptions(
        block_size=64 * 1024 * 1024,
        use_threads=True,
        column_names=columns,
        skip_rows=1,
        encoding="utf8",
    )
    convert_options = pacsv.ConvertOptions(
        column_types={column: pa.string() for column in columns},
        strings_can_be_null=True,
    )
    reader = pacsv.open_csv(source, read_options=read_options, convert_options=convert_options)

    try:
        for batch in reader:
            table = pa.Table.from_batches([batch])
            if schema is None:
                schema = table.schema
            years = table.column("priority_year").to_pylist()
            labels = [period_label(int(value)) if value is not None else "unknown_year" for value in years]
            for label in sorted(set(labels)):
                indices = pa.array([index for index, item in enumerate(labels) if item == label])
                subset = table.take(indices)
                target = data_dir / f"patstat_ai_{label}.parquet"
                if label not in writers:
                    writers[label] = pq.ParquetWriter(
                        target,
                        subset.schema,
                        compression="zstd",
                        compression_level=6,
                        use_dictionary=True,
                    )
                writers[label].write_table(subset, row_group_size=50_000)
                counts[label] = counts.get(label, 0) + subset.num_rows
    finally:
        for writer in writers.values():
            writer.close()

    if schema is None:
        raise RuntimeError("The source dataset is empty.")

    manifest_rows = []
    for path in sorted(data_dir.glob("*.parquet")):
        label = path.stem.removeprefix("patstat_ai_")
        manifest_rows.append(
            {
                "category": label,
                "rows": counts[label],
                "bytes": path.stat().st_size,
                "sha256": sha256(path),
                "path": str(path.relative_to(output_dir)),
            }
        )

    metadata_dir = output_dir / "metadata"
    metadata_dir.mkdir(parents=True, exist_ok=True)
    with (metadata_dir / "file_manifest.csv").open("w", encoding="utf-8", newline="") as stream:
        writer = csv.DictWriter(stream, fieldnames=["category", "rows", "bytes", "sha256", "path"])
        writer.writeheader()
        writer.writerows(manifest_rows)
    with (metadata_dir / "schema.json").open("w", encoding="utf-8") as stream:
        json.dump(
            [{"name": field.name, "type": str(field.type), "nullable": field.nullable} for field in schema],
            stream,
            indent=2,
        )

    return {
        "source": str(source),
        "source_sha256": sha256(source),
        "rows": sum(counts.values()),
        "columns": len(schema),
        "categories": counts,
        "files": manifest_rows,
    }


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--source", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    args = parser.parse_args()
    args.output.mkdir(parents=True, exist_ok=True)
    result = build_dataset(args.source, args.output)
    copy_supporting_files(args.source.parent, args.output)
    with (args.output / "metadata" / "build_summary.json").open("w", encoding="utf-8") as stream:
        json.dump(result, stream, indent=2)
    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()