Add files using upload-large-folder tool

README.md

@@ -0,0 +1,281 @@
+---
+pretty_name: PubMed Metadata V2
+license: other
+language:
+- multilingual
+task_categories:
+- text-retrieval
+size_categories:
+- 10M<n<100M
+tags:
+- pubmed
+- pubmed-central
+- biomedical
+- scholarly-metadata
+- open-access
+dataset_info:
+  features:
+  - name: pmid
+    dtype: uint32
+  - name: pmcid
+    dtype: large_string
+  - name: doi
+    dtype: large_string
+  - name: title
+    dtype: large_string
+  - name: abstract
+    dtype: large_string
+  - name: journal
+    dtype: large_string
+  - name: year
+    dtype: uint16
+  - name: publication_month
+    dtype: uint8
+  - name: publication_day
+    dtype: uint8
+  - name: issn
+    dtype: large_string
+  - name: eissn
+    dtype: large_string
+  - name: is_oa
+    dtype: bool
+  - name: issn_linking
+    dtype: large_string
+  - name: journal_abbrev
+    dtype: large_string
+  - name: nlm_unique_id
+    dtype: large_string
+  - name: country
+    dtype: large_string
+  - name: volume
+    dtype: large_string
+  - name: issue
+    dtype: large_string
+  - name: pages
+    dtype: large_string
+  - name: date_completed
+    dtype: date32
+  - name: date_revised
+    dtype: date32
+  - name: citation_status
+    dtype: string
+  - name: publication_status
+    dtype: string
+  - name: pub_model
+    dtype: string
+  - name: vernacular_title
+    dtype: large_string
+  - name: authors
+    large_list:
+    - name: display_name
+      dtype: large_string
+    - name: last_name
+      dtype: large_string
+    - name: fore_name
+      dtype: large_string
+    - name: initials
+      dtype: large_string
+    - name: suffix
+      dtype: large_string
+    - name: collective_name
+      dtype: large_string
+    - name: orcid
+      dtype: large_string
+    - name: affiliations
+      large_list: large_string
+    - name: valid
+      dtype: bool
+    - name: equal_contrib
+      dtype: bool
+  - name: publication_types
+    large_list: large_string
+  - name: languages
+    large_list: large_string
+  - name: mesh_terms
+    large_list: large_string
+  - name: mesh_major_topics
+    large_list: large_string
+  - name: keywords
+    large_list: large_string
+  - name: article_ids
+    large_list: large_string
+  splits:
+  - name: train
+    num_examples: 41860640
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*
+---
+
+# PubMed Metadata V2
+
+An updated, V1-schema-compatible Parquet snapshot of PubMed citation metadata,
+augmented with PMC records that were not safely represented in PubMed's current
+PMID-to-PMCID mapping.
+
+The PubMed portion was built from the NLM PubMed 2026 annual baseline and daily
+update XML files through `pubmed26n1592.xml.gz`. Updates are applied in numeric
+order, revised records replace earlier versions, and citations whose latest event
+is a deletion are omitted. The dataset was built on 2026-08-16.
+
+The single `train` split contains **41,860,640 records**:
+
+- 40,990,549 records have a unique, non-null PMID;
+- 870,091 PMC-only records have a null PMID and are keyed by PMCID;
+- 879,135 validated PMC records were added to the current PubMed snapshot; and
+- 2,553 existing PMID rows were safely updated with their missing PMCID and
+  available metadata.
+
+Compared with `haydn-jones/PubMed-Metadata`, V2 has 915,429 additional records and
+retains the same 32 columns and logical Arrow types. Ambiguous identifier conflicts
+were excluded rather than guessed. PMC matching and external metadata retrieval used
+exact PMCID or DOI identifiers only; no title/author fuzzy matching was used.
+
+## Usage
+
+Streaming avoids downloading the entire dataset:
+
+```python
+from datasets import load_dataset
+
+papers = load_dataset(
+    "haydn-jones/PubMed-Metadata-V2",
+    split="train",
+    streaming=True,
+)
+
+first_paper = next(iter(papers))
+```
+
+For a local memory-mapped dataset:
+
+```python
+from datasets import load_dataset
+
+papers = load_dataset("haydn-jones/PubMed-Metadata-V2", split="train")
+```
+
+PMID remains unique whenever present. For a unique key across the whole dataset,
+use the PMID when non-null and otherwise use the PMCID.
+
+## Open-access flag
+
+`is_oa` is a non-null operational full-text accessibility flag:
+
+```text
+pmcid is present
+OR
+(issn, eissn, or issn_linking matches a current DOAJ journal
+ AND publication year >= that journal's all-content open-license start year)
+```
+
+- 12,906,383 rows are marked `is_oa=true`.
+- 12,338,603 rows have a PMCID; every one is marked `is_oa=true`.
+- 567,780 rows are marked open through the date-aware DOAJ rule without a PMCID.
+
+This flag indicates practical full-text accessibility. It does **not** assert that
+an article has a permissive reuse license: PMC content has article-specific rights,
+and users must check the applicable license before reuse.
+
+## Columns
+
+| Column | Type | Description |
+|---|---|---|
+| `pmid` | `uint32` | PubMed identifier; unique when present. Null for PMC-only records without a safely resolved PMID. |
+| `pmcid` | string | PubMed Central identifier, when available. |
+| `doi` | string | Digital Object Identifier, normalized to its identifier value. |
+| `title` | string | Article or book-document title as plain text. |
+| `abstract` | string | Abstract sections joined with newlines; section labels are retained. |
+| `journal` | string | Full journal title. |
+| `year` | `uint16` | Best available publication year. |
+| `publication_month` | `uint8` | Explicit publication month, when available. |
+| `publication_day` | `uint8` | Explicit publication day, when available. |
+| `issn` | string | Print ISSN. |
+| `eissn` | string | Electronic ISSN. |
+| `is_oa` | boolean | PMCID-or-date-aware-DOAJ accessibility flag described above. |
+| `issn_linking` | string | NLM linking ISSN used to associate journal formats and title histories. |
+| `journal_abbrev` | string | NLM/ISO journal abbreviation. |
+| `nlm_unique_id` | string | NLM Catalog identifier for the journal. |
+| `country` | string | Journal publication country recorded by NLM. |
+| `volume` | string | Journal volume; kept as text because values are not always numeric. |
+| `issue` | string | Journal issue; kept as text because values are not always numeric. |
+| `pages` | string | Pagination or electronic location text. |
+| `date_completed` | date | Date NLM completed processing the citation. |
+| `date_revised` | date | Most recent explicit revision date in the record. |
+| `citation_status` | string | PubMed/Medline citation status. |
+| `publication_status` | string | PubMed publication status such as `ppublish` or `epublish`. |
+| `pub_model` | string | Print/electronic publication model. |
+| `vernacular_title` | string | Title in the original language, when supplied separately. |
+| `authors` | list of structs | Ordered authors, including names, ORCID, affiliations, validity, and equal-contribution metadata. |
+| `publication_types` | list of strings | NLM publication-type labels. |
+| `languages` | list of strings | PubMed language codes. |
+| `mesh_terms` | list of strings | MeSH descriptor headings assigned to the citation. |
+| `mesh_major_topics` | list of strings | MeSH descriptors or descriptor/qualifier combinations marked as major topics. |
+| `keywords` | list of strings | Author, publisher, or indexing keywords. |
+| `article_ids` | list of strings | Identifier values carried in the source record. |
+
+Each element of `authors` has this structure:
+
+```text
+display_name: string
+last_name: string
+fore_name: string
+initials: string
+suffix: string
+collective_name: string
+orcid: string
+affiliations: list[string]
+valid: bool
+equal_contrib: bool
+```
+
+## Reproduction
+
+The PubMed XML parsing and cleaning scripts are included under `scripts/`. The DOAJ
+journal CSV used for the date-aware OA flag is included under `sources/`.
+
+Mirror the PubMed baseline and updates from NCBI, including checksum sidecars:
+
+```bash
+lftp -e "
+  set net:connection-limit 8;
+  mirror --parallel=8 --continue --use-pget-n=4 \
+    -I '*.xml.gz' -I '*.xml.gz.md5' \
+    /pubmed/baseline/ /path/to/pubmed/baseline/;
+  mirror --parallel=8 --continue --use-pget-n=4 \
+    -I '*.xml.gz' -I '*.xml.gz.md5' \
+    /pubmed/updatefiles/ /path/to/pubmed/updatefiles/;
+  quit
+" https://ftp.ncbi.nlm.nih.gov
+```
+
+Build a current-state raw Parquet file:
+
+```bash
+uv run --with pyarrow --with tqdm python scripts/pubmed_xml_to_parquet.py \
+  --input-root /path/to/pubmed \
+  --output papers.parquet \
+  --workers 8
+```
+
+Produce the typed, DOAJ-enriched file:
+
+```bash
+uv run --with polars --with pyarrow python scripts/clean_pubmed_parquet.py \
+  papers.parquet papers_clean.parquet \
+  --doaj-csv sources/doaj_journalcsv_20260709_2320_utf8.csv
+```
+
+Both scripts write through a partial file and replace the destination atomically.
+The XML builder validates the NLM MD5 sidecars by default.
+
+## Sources and terms
+
+- Citation metadata: [NLM PubMed baseline and daily update files](https://pubmed.ncbi.nlm.nih.gov/download/).
+- PMC metadata: [PubMed Central Open Access bulk data](https://pmc.ncbi.nlm.nih.gov/tools/ftp/).
+- OA journal metadata: [DOAJ Journal CSV](https://doaj.org/docs/journal-csv).
+- DOAJ metadata terms: [DOAJ terms and conditions](https://doaj.org/terms/).
+- Additional exact-identifier gap filling used NCBI ESummary, Europe PMC, OpenAlex,
+  and Crossref metadata.

data/train-00000-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:866f8e154d43d302e950d792e9e72abb9193a65d0007fd9856df9f2feb9ae67a
+size 27935538

data/train-00001-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ea497d4a1068e5d2cc11686323916f7e639c351867889f9046ee7292738cc21
+size 46623876

data/train-00002-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:018996ff6451169c342c32bd04f962bfe0da1d48f1118aeefa77df7ab222af4b
+size 43904224

data/train-00003-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d59640166eebfe7855082fdbb8d4ae6fedbd3c377e7d456bc41917796f2e487d
+size 62967113

data/train-00004-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4af56e06ec794735599d5167cc6c812f26198f861db1c58352526ce3ea6bd3c
+size 49638807

data/train-00005-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9ac00116798b6ba4cb1453f6b0659ade98393866f58be7f7598229ac41b0ce1
+size 67510994

data/train-00006-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d796cb304a6ba8c104490516f05360857d3e6d6eddb4105ba6a36522b0b6c3d1
+size 62352905

data/train-00007-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:999cc5a3c321ceaab2d401d45302de59dbe5651a419852f9de52855a3d193904
+size 60850009

data/train-00008-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5dbab1c10f128a84cf7215e94b567626e9226c2bb03506a065e9d43a0fbe354f
+size 51821746

data/train-00009-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4424d5f7e9237e356cfbfdac2e5a355e01630e7527bcc2ea02b46b85e5db32b8
+size 44834522

data/train-00010-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3be23f922785178804ef5f380f8b1bb345bbc7918335b03cc910f7d12d205a6b
+size 59711503

data/train-00011-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e516a076b4f2583e152abb12e0aeef4f9341f7f6b15ada84b0e47fb7c0ed1a3
+size 66966669

data/train-00012-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8646b9b94bc8013287c3af61bc9f4eaba6119c99def78f52f2e0d5c2ed8d06b7
+size 55741717

data/train-00013-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9dbd7cd460db8cceca173cf6ad99c2b25592fc04b8fa1b25939a11d9f094bd13
+size 43525945

data/train-00014-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2136c4c3b540e41f7c40cdc148ca8bed2e12de416a1b863f5c971358c8549d81
+size 50783945

data/train-00015-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54395cc44ad07da4c728b6a32c3e325e511304cdab7bff2ea78cd3e488f90c80
+size 49743987

data/train-00016-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf7b2e44ad4ac9bd77b11e2e61a44c32c01c3c8743f8357d46019503264bef80
+size 50539484

data/train-00017-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ccbc2df419f1b1ec86ff54f3e584472cf753207429e49e0a56984f83191eb702
+size 63468580

data/train-00018-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ca1d7ab96ba937787c93993ea7db81d99b9d6a7cbdaf2e7ed5421782cbfe8fb
+size 47374252

data/train-00019-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cb844cd95940f5f1ea6c7825b2ecd5334b5939d1c13ed0aff83b77f4514d96f
+size 82080435

data/train-00020-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6046d9d657e986e856acf52181eca3020a3a4c57c1e4af143c10c4fc9e2033a3
+size 73379015

data/train-00021-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3894d42439e2992688aec86a2fe1044845d4f0fcc1ba826f438db1a641a3859e
+size 70267072

data/train-00022-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78c31885e7f8adb68b8adb9cde6c949931b8c8d92c82da41af27e7aa7a4e2722
+size 43778256

data/train-00023-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:711b31281370bb4d25820008d751c8ba8cfa5c6246568ff915ec10c3a703fce1
+size 61530143

data/train-00024-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8888a28c942fcf054fcba7b6d07806db95733960ab3f23b373417cb681200c03
+size 64821060

data/train-00025-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:707bad7a8fe9427067b8fe32f83cc0e8f6ca28d38308452b83c07c94d0ee482e
+size 49371703

data/train-00026-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86ba5f2890a3a5fb5ee25ce380e2d8568576f55bee8ec02680ab187b4a76dff6
+size 63968778

data/train-00027-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:80c24730f9bf29936e39f9c33892bd40922dddc5176a2da118e10001b66c36d3
+size 38828286

data/train-00028-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7affa9650a3f396326efcc9aabd8b64884e8c25046f0549ad52160e16e2e89c
+size 63769918

data/train-00029-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79beb6acd02e771f55be954b6c789f54f8dd059fba34a0dc6af84dafda73476c
+size 60207928

data/train-00030-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:610a34840fb8244bd9ed4546ba929d71602125c9fdb5d6dac6afb9d4d4976eb4
+size 55972178

data/train-00031-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8156109ccaa74ea92e49bbf12fb0b5c4beb6f5a6ad2a22617f9c6b8b9fbbee1
+size 63800231

data/train-00032-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0fcb85b8306bfcbb0ecbf03febd26693dad4ed5b546575327e44fc4ef5d30699
+size 63322953

data/train-00033-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47eb6d96e622764d4502bbf9884d9e1557ba0fa7c6846748bef9ef5264aaca12
+size 53050831

data/train-00034-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0772919787febd2c8e0a61f0cfe064415b58a7a0f1d923b0f44a6a8e326091f5
+size 82622056

data/train-00035-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d17c115343cfa312d0866116605c98dd9c977cd78c6885245b312ca46c617bd7
+size 66464741

data/train-00036-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05ace61943cadef4a1476e703c393791e59954ec13650cf64bd76f5141299eff
+size 62260948

data/train-00037-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cbe1ef15f86f3dcae0119b20b8417494a511c115679bee4cbc9646cba4468a55
+size 61694372

data/train-00038-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5aa351ac776593aac47e80b7811b9408e2ea01f00a196cdcd9cb4da40c9dd018
+size 67415677

data/train-00039-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2b0b84d7dfa74f92c35dff5064103cd7451a4d8c318e47a702120008c4b05b9
+size 92999623

data/train-00040-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b2a0c60a1561079e9d24321d82c1f2d0081d94f162b4bf801c85d9b8055fed
+size 60971355

data/train-00041-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93a6927436f6c38457610df4f69ed74c129dbb82191e5d9874fdf3a9d96afebe
+size 76476465

data/train-00042-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cae38c33a1cb71b0411675d53853fc523c233c5a798a436dda9bee543ef8bba3
+size 88006811

data/train-00043-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9220578679065ea2fccb31dd7e6c688e913542bf841c1aaa34352de45eccfce
+size 71083310

data/train-00044-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:147cde15b7e42aa4a1bccf69a9b7357904881189106b1c5a01f9f58b99425d2b
+size 49601398

data/train-00045-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56feecc6c435fc0c999770966bd3ba8c10d5071ff9ae7562d21dbcd466b07b2c
+size 60237327

data/train-00046-of-00210.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f73a24bc55daefad7fc63b2d0fed8d68b0c55ccc89215a3fce48e9883eaa7e9
+size 72631487

scripts/clean_pubmed_parquet.py

@@ -0,0 +1,174 @@
+"""Rewrite PubMed metadata Parquet with compact, query-friendly scalar types."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import re
+from datetime import datetime
+from pathlib import Path
+
+import polars as pl
+import pyarrow.parquet as pq
+
+CITATION_STATUS = pl.Enum(["In-Data-Review", "In-Process", "MEDLINE", "PubMed-not-MEDLINE", "Publisher"])
+PUBLICATION_STATUS = pl.Enum(["aheadofprint", "epublish", "ppublish"])
+PUB_MODEL = pl.Enum(["Electronic", "Electronic-Print", "Electronic-eCollection", "Print", "Print-Electronic"])
+DOAJ_START_YEAR = "When did the journal start to publish all content using an open license?"
+DOAJ_PRINT_ISSN = "Journal ISSN (print version)"
+DOAJ_EISSN = "Journal EISSN (online version)"
+DOAJ_COMPLIES = "Does the journal comply to DOAJ's definition of open access?"
+
+
+def _parquet_metadata(path: Path) -> dict[str, str]:
+    metadata = pq.read_metadata(path).metadata or {}
+    return {key.decode(): value.decode() for key, value in metadata.items() if key != b"ARROW:schema"}
+
+
+def _normalized_issn(column: str) -> pl.Expr:
+    return pl.col(column).cast(pl.String).str.to_uppercase().str.replace_all(r"[^0-9X]", "")
+
+
+def _doaj_issn_start_years(path: Path) -> pl.DataFrame:
+    if not path.is_file():
+        raise FileNotFoundError(path)
+
+    journals = pl.read_csv(
+        path,
+        columns=[DOAJ_PRINT_ISSN, DOAJ_EISSN, DOAJ_START_YEAR, DOAJ_COMPLIES],
+        schema_overrides={
+            DOAJ_PRINT_ISSN: pl.String,
+            DOAJ_EISSN: pl.String,
+            DOAJ_START_YEAR: pl.String,
+            DOAJ_COMPLIES: pl.String,
+        },
+        null_values="",
+    ).filter(pl.col(DOAJ_COMPLIES) == "Yes")
+    issns = pl.concat([
+        journals.select(pl.col(DOAJ_PRINT_ISSN).alias("issn"), pl.col(DOAJ_START_YEAR)),
+        journals.select(pl.col(DOAJ_EISSN).alias("issn"), pl.col(DOAJ_START_YEAR)),
+    ]).with_columns(
+        _normalized_issn("issn").alias("issn"),
+        pl.col(DOAJ_START_YEAR).cast(pl.UInt16).alias("oa_start_year"),
+    )
+    return issns.filter(pl.col("issn").str.len_chars() == 8).group_by("issn").agg(pl.col("oa_start_year").min())
+
+
+def _add_is_oa(source: pl.LazyFrame, doaj_csv_path: Path) -> pl.LazyFrame:
+    lookup = _doaj_issn_start_years(doaj_csv_path).lazy()
+    issn_columns = ["issn", "eissn", "issn_linking"]
+    source = source.with_columns(*(_normalized_issn(column).alias(f"__{column}") for column in issn_columns))
+    start_columns: list[str] = []
+    for column in issn_columns:
+        key = f"__{column}"
+        start = f"__{column}_oa_start_year"
+        start_columns.append(start)
+        source = source.join(
+            lookup.rename({"issn": key, "oa_start_year": start}),
+            on=key,
+            how="left",
+        )
+
+    return source.with_columns(pl.min_horizontal(start_columns).alias("__oa_start_year")).with_columns(
+        (pl.col("pmcid").is_not_null() | (pl.col("year") >= pl.col("__oa_start_year")).fill_null(False)).alias("is_oa")
+    )
+
+
+def _doaj_metadata(path: Path, lookup_rows: int) -> dict[str, str]:
+    with path.open("rb") as handle:
+        checksum = hashlib.file_digest(handle, "sha256").hexdigest()
+    date_match = re.search(r"doaj_journalcsv_(\d{8})", path.name)
+    snapshot_date = datetime.strptime(date_match.group(1), "%Y%m%d").date().isoformat() if date_match else "unknown"
+    return {
+        "doaj_source": "https://doaj.org/csv",
+        "doaj_snapshot_date": snapshot_date,
+        "doaj_csv_sha256": checksum,
+        "doaj_unique_issns": str(lookup_rows),
+        "is_oa_definition": (
+            "true when PMCID is present, or when issn, eissn, or issn_linking matches a current DOAJ journal "
+            "and publication year is at least the journal's all-content open-license start year; this indicates "
+            "practical full-text accessibility, not necessarily a permissive reuse license"
+        ),
+    }
+
+
+def clean_pubmed_parquet(
+    input_path: Path,
+    output_path: Path,
+    *,
+    doaj_csv_path: Path | None = None,
+    overwrite: bool = False,
+) -> None:
+    """Stream ``input_path`` into an atomically replaced, typed Parquet file."""
+    if not input_path.is_file():
+        raise FileNotFoundError(input_path)
+    if output_path.exists() and not overwrite:
+        raise FileExistsError(f"Output already exists: {output_path}; pass --overwrite to replace it")
+
+    partial_path = output_path.with_name(f".{output_path.name}.partial")
+    if partial_path.exists():
+        raise FileExistsError(f"Refusing to overwrite existing partial output: {partial_path}")
+
+    source = pl.scan_parquet(input_path)
+    source_columns = source.collect_schema().names()
+    if "publication_date" not in source_columns:
+        raise ValueError("Input is missing required publication_date column")
+
+    output_columns = (
+        source_columns[:7]
+        + ["publication_month", "publication_day"]
+        + [column for column in source_columns[7:] if column != "publication_date"]
+    )
+    if doaj_csv_path is not None:
+        source = _add_is_oa(source, doaj_csv_path)
+        output_columns.insert(output_columns.index("eissn") + 1, "is_oa")
+    typed = source.with_columns(
+        pl.col("pmid").cast(pl.UInt32),
+        pl.col("year").cast(pl.UInt16),
+        pl.col("publication_date").str.slice(5, 2).cast(pl.UInt8, strict=False).alias("publication_month"),
+        pl.col("publication_date").str.slice(8, 2).cast(pl.UInt8, strict=False).alias("publication_day"),
+        pl.col("date_completed").str.to_date("%Y-%m-%d", strict=True),
+        pl.col("date_revised").str.to_date("%Y-%m-%d", strict=True),
+        pl.col("citation_status").cast(CITATION_STATUS),
+        pl.col("publication_status").cast(PUBLICATION_STATUS),
+        pl.col("pub_model").cast(PUB_MODEL),
+    ).select(output_columns)
+
+    metadata = _parquet_metadata(input_path)
+    metadata["transform"] = (
+        "pmid=uint32; year=uint16; publication_date split into uint8 month/day; "
+        "completion/revision dates=date32; bounded statuses=enum"
+    )
+    if doaj_csv_path is not None:
+        metadata.update(_doaj_metadata(doaj_csv_path, _doaj_issn_start_years(doaj_csv_path).height))
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        typed.sink_parquet(
+            partial_path,
+            compression="zstd",
+            compression_level=3,
+            statistics=True,
+            row_group_size=100_000,
+            data_page_size=1024 * 1024,
+            maintain_order=True,
+            sync_on_close="data",
+            metadata=metadata,
+        )
+        partial_path.replace(output_path)
+    except BaseException:
+        partial_path.unlink(missing_ok=True)
+        raise
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("input", type=Path, help="Source PubMed Parquet")
+    parser.add_argument("output", type=Path, help="Destination clean Parquet")
+    parser.add_argument("--doaj-csv", type=Path, help="DOAJ journal CSV used to derive is_oa")
+    parser.add_argument("--overwrite", action="store_true", help="Atomically replace an existing output")
+    args = parser.parse_args()
+    clean_pubmed_parquet(args.input, args.output, doaj_csv_path=args.doaj_csv, overwrite=args.overwrite)
+
+
+if __name__ == "__main__":
+    main()

scripts/pubmed_xml_to_parquet.py

@@ -0,0 +1,838 @@
+"""Build a current PubMed metadata Parquet file from NCBI's XML distribution.
+
+The input directory is expected to contain the two directories mirrored from NCBI::
+
+    pubmed/
+      baseline/pubmed26n0001.xml.gz ...
+      updatefiles/pubmed26n1335.xml.gz ...
+
+The baseline is a snapshot. Update files contain new, revised, and deleted records.
+This script indexes the last update event for every PMID, writes unchanged baseline
+records, and then writes only the final live version from the updates. The result has
+one row per current PMID without needing to hold the corpus in memory.
+
+Example::
+
+    uv run --group dev python scripts/pubmed_xml_to_parquet.py \
+      --input-root /mnt/data/pubmed_corpus/pubmed \
+      --output /mnt/data/pubmed_corpus/papers.parquet
+"""
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures
+import contextlib
+import gzip
+import hashlib
+import os
+import re
+import sqlite3
+import tempfile
+from collections import deque
+from collections.abc import Callable, Iterable, Iterator, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from xml.etree import ElementTree as ET
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+from tqdm.auto import tqdm
+
+DEFAULT_INPUT_ROOT = Path("/mnt/data/pubmed_corpus/pubmed")
+DEFAULT_WORKERS = min(8, os.process_cpu_count() or 1)
+FILE_RE = re.compile(r"^pubmed(?P<release>\d{2})n(?P<sequence>\d{4})\.xml\.gz$")
+YEAR_RE = re.compile(r"(?<!\d)(1[5-9]\d{2}|20\d{2}|2100)(?!\d)")
+WHITESPACE_RE = re.compile(r"\s+")
+ORCID_URL_RE = re.compile(r"^https?://orcid\.org/", re.IGNORECASE)
+SQLITE_QUERY_CHUNK = 900
+
+MONTHS = {
+    "jan": 1,
+    "feb": 2,
+    "mar": 3,
+    "apr": 4,
+    "may": 5,
+    "jun": 6,
+    "jul": 7,
+    "aug": 8,
+    "sep": 9,
+    "oct": 10,
+    "nov": 11,
+    "dec": 12,
+}
+
+AUTHOR_TYPE = pa.struct([
+    pa.field("display_name", pa.string(), nullable=False),
+    pa.field("last_name", pa.string()),
+    pa.field("fore_name", pa.string()),
+    pa.field("initials", pa.string()),
+    pa.field("suffix", pa.string()),
+    pa.field("collective_name", pa.string()),
+    pa.field("orcid", pa.string()),
+    pa.field("affiliations", pa.list_(pa.string())),
+    pa.field("valid", pa.bool_(), nullable=False),
+    pa.field("equal_contrib", pa.bool_()),
+])
+
+PARQUET_SCHEMA = pa.schema([
+    pa.field("pmid", pa.string(), nullable=False),
+    pa.field("pmcid", pa.string()),
+    pa.field("doi", pa.string()),
+    pa.field("title", pa.string()),
+    pa.field("abstract", pa.string()),
+    pa.field("journal", pa.string()),
+    pa.field("year", pa.int64()),
+    pa.field("issn", pa.string()),
+    pa.field("eissn", pa.string()),
+    pa.field("issn_linking", pa.string()),
+    pa.field("journal_abbrev", pa.string()),
+    pa.field("nlm_unique_id", pa.string()),
+    pa.field("country", pa.string()),
+    pa.field("volume", pa.string()),
+    pa.field("issue", pa.string()),
+    pa.field("pages", pa.string()),
+    pa.field("publication_date", pa.string()),
+    pa.field("date_completed", pa.string()),
+    pa.field("date_revised", pa.string()),
+    pa.field("citation_status", pa.string()),
+    pa.field("publication_status", pa.string()),
+    pa.field("pub_model", pa.string()),
+    pa.field("vernacular_title", pa.string()),
+    pa.field("authors", pa.list_(AUTHOR_TYPE)),
+    pa.field("publication_types", pa.list_(pa.string())),
+    pa.field("languages", pa.list_(pa.string())),
+    pa.field("mesh_terms", pa.list_(pa.string())),
+    pa.field("mesh_major_topics", pa.list_(pa.string())),
+    pa.field("keywords", pa.list_(pa.string())),
+    pa.field("article_ids", pa.list_(pa.string())),
+])
+
+Record = dict[str, Any]
+
+
+@dataclass(frozen=True)
+class DistributionFile:
+    path: Path
+    release: int
+    sequence: int
+
+
+@dataclass
+class ParsedFile:
+    table: pa.Table
+    event_count: int
+
+
+def _local_name(tag: str) -> str:
+    """Return an XML local name, including for embedded namespaced content."""
+    return tag.rsplit("}", 1)[-1]
+
+
+def _element_text(element: ET.Element | None) -> str | None:
+    """Extract mixed XML content and normalize formatting whitespace."""
+    if element is None:
+        return None
+    text = WHITESPACE_RE.sub(" ", "".join(element.itertext())).strip()
+    return text or None
+
+
+def _text_at(parent: ET.Element | None, path: str) -> str | None:
+    return _element_text(parent.find(path)) if parent is not None else None
+
+
+def _texts_at(parent: ET.Element | None, path: str) -> list[str]:
+    if parent is None:
+        return []
+    return [text for element in parent.findall(path) if (text := _element_text(element)) is not None]
+
+
+def _unique(values: Iterable[str]) -> list[str]:
+    return list(dict.fromkeys(value for value in values if value))
+
+
+def _abstract(parent: ET.Element | None) -> str | None:
+    if parent is None:
+        return None
+    sections: list[str] = []
+    for element in parent.findall("Abstract/AbstractText"):
+        text = _element_text(element)
+        if text is None:
+            continue
+        label = WHITESPACE_RE.sub(" ", element.attrib.get("Label", "")).strip()
+        sections.append(f"{label}: {text}" if label else text)
+    return "\n".join(sections) or None
+
+
+def _authors(parent: ET.Element | None, paths: Sequence[str]) -> list[Record]:
+    if parent is None:
+        return []
+
+    authors: list[Record] = []
+    for path in paths:
+        for author in parent.findall(path):
+            collective_name = _text_at(author, "CollectiveName")
+            last_name = _text_at(author, "LastName")
+            fore_name = _text_at(author, "ForeName")
+            initials = _text_at(author, "Initials")
+            suffix = _text_at(author, "Suffix")
+            if collective_name:
+                display_name = collective_name
+            else:
+                display_name = " ".join(
+                    part
+                    for part in (
+                        fore_name,
+                        last_name,
+                        suffix,
+                    )
+                    if part
+                )
+
+            orcid: str | None = None
+            for identifier in author.findall("Identifier"):
+                if identifier.attrib.get("Source", "").casefold() != "orcid":
+                    continue
+                if value := _element_text(identifier):
+                    orcid = orcid or ORCID_URL_RE.sub("", value)
+
+            equal_contrib_attribute = author.attrib.get("EqualContrib")
+            authors.append({
+                "display_name": display_name,
+                "last_name": last_name,
+                "fore_name": fore_name,
+                "initials": initials,
+                "suffix": suffix,
+                "collective_name": collective_name,
+                "orcid": orcid,
+                "affiliations": _unique(_texts_at(author, "AffiliationInfo/Affiliation")),
+                "valid": author.attrib.get("ValidYN", "Y") == "Y",
+                "equal_contrib": (equal_contrib_attribute == "Y" if equal_contrib_attribute is not None else None),
+            })
+
+    return authors
+
+
+def _article_ids(*parents: ET.Element | None) -> tuple[dict[str, list[str]], list[str]]:
+    by_type: dict[str, list[str]] = {}
+    flattened: list[str] = []
+    for parent in parents:
+        if parent is None:
+            continue
+        for element in parent.findall("ArticleIdList/ArticleId"):
+            value = _element_text(element)
+            if value is None:
+                continue
+            id_type = element.attrib.get("IdType", "unknown").casefold()
+            values = by_type.setdefault(id_type, [])
+            if value not in values:
+                values.append(value)
+            flattened.append(f"{id_type}:{value}")
+    return by_type, _unique(flattened)
+
+
+def _date_parts(parent: ET.Element | None) -> tuple[int | None, str | None]:
+    if parent is None:
+        return None, None
+
+    year_text = _text_at(parent, "Year")
+    medline_date = _text_at(parent, "MedlineDate")
+    year: int | None = None
+    if year_text and year_text.isdigit():
+        year = int(year_text)
+    elif medline_date and (match := YEAR_RE.search(medline_date)):
+        year = int(match.group(1))
+
+    if year is None:
+        return None, medline_date
+
+    month_text = _text_at(parent, "Month")
+    day_text = _text_at(parent, "Day")
+    month: int | None = None
+    if month_text:
+        if month_text.isdigit() and 1 <= int(month_text) <= 12:
+            month = int(month_text)
+        else:
+            month = MONTHS.get(month_text[:3].casefold())
+
+    if month is None:
+        return year, str(year)
+    if day_text and day_text.isdigit() and 1 <= int(day_text) <= 31:
+        return year, f"{year:04d}-{month:02d}-{int(day_text):02d}"
+    return year, f"{year:04d}-{month:02d}"
+
+
+def _simple_date(parent: ET.Element | None) -> str | None:
+    _, value = _date_parts(parent)
+    return value
+
+
+def _publication_date(
+    article: ET.Element | None,
+    pubmed_data: ET.Element | None,
+    *,
+    book: ET.Element | None = None,
+) -> tuple[int | None, str | None]:
+    candidates: list[ET.Element | None] = []
+    if article is not None:
+        candidates.extend([
+            article.find("Journal/JournalIssue/PubDate"),
+            article.find("ArticleDate"),
+        ])
+    if book is not None:
+        candidates.append(book.find("PubDate"))
+    if pubmed_data is not None:
+        history = pubmed_data.find("History")
+        if history is not None:
+            by_status = {date.attrib.get("PubStatus"): date for date in history.findall("PubMedPubDate")}
+            candidates.extend(by_status.get(status) for status in ("ppublish", "epublish", "pubmed", "entrez"))
+
+    for candidate in candidates:
+        year, value = _date_parts(candidate)
+        if year is not None:
+            return year, value
+    return None, None
+
+
+def _journal_issns(journal: ET.Element | None) -> tuple[str | None, str | None]:
+    if journal is None:
+        return None, None
+    print_issn: str | None = None
+    electronic_issn: str | None = None
+    for element in journal.findall("ISSN"):
+        value = _element_text(element)
+        if value is None:
+            continue
+        issn_type = element.attrib.get("IssnType", "").casefold()
+        if issn_type == "electronic":
+            electronic_issn = electronic_issn or value
+        elif issn_type == "print":
+            print_issn = print_issn or value
+    return print_issn, electronic_issn
+
+
+def _mesh(citation: ET.Element | None) -> tuple[list[str], list[str]]:
+    if citation is None:
+        return [], []
+    terms: list[str] = []
+    major_topics: list[str] = []
+    for heading in citation.findall("MeshHeadingList/MeshHeading"):
+        descriptor = heading.find("DescriptorName")
+        descriptor_text = _element_text(descriptor)
+        if descriptor_text is None:
+            continue
+        terms.append(descriptor_text)
+        if descriptor is not None and descriptor.attrib.get("MajorTopicYN") == "Y":
+            major_topics.append(descriptor_text)
+        for qualifier in heading.findall("QualifierName"):
+            qualifier_text = _element_text(qualifier)
+            if qualifier_text and qualifier.attrib.get("MajorTopicYN") == "Y":
+                major_topics.append(f"{descriptor_text}/{qualifier_text}")
+    return _unique(terms), _unique(major_topics)
+
+
+def _parse_journal_article(element: ET.Element) -> Record:
+    citation = element.find("MedlineCitation")
+    if citation is None:
+        raise ValueError("PubmedArticle has no MedlineCitation")
+    article = citation.find("Article")
+    pubmed_data = element.find("PubmedData")
+    journal = article.find("Journal") if article is not None else None
+    journal_info = citation.find("MedlineJournalInfo")
+
+    pmid = _text_at(citation, "PMID")
+    if pmid is None:
+        raise ValueError("PubmedArticle has no PMID")
+
+    ids, flattened_ids = _article_ids(pubmed_data)
+    if article is not None:
+        for e_location in article.findall("ELocationID"):
+            if e_location.attrib.get("EIdType", "").casefold() != "doi":
+                continue
+            if value := _element_text(e_location):
+                ids.setdefault("doi", []).append(value)
+                flattened_ids.append(f"doi:{value}")
+
+    print_issn, electronic_issn = _journal_issns(journal)
+    year, publication_date = _publication_date(article, pubmed_data)
+    authors = _authors(article, ("AuthorList/Author",))
+    mesh_terms, mesh_major_topics = _mesh(citation)
+
+    return {
+        "pmid": pmid,
+        "pmcid": (ids.get("pmc") or ids.get("pmcid") or [None])[0],
+        "doi": (ids.get("doi") or [None])[0],
+        "title": _text_at(article, "ArticleTitle"),
+        "abstract": _abstract(article),
+        "journal": _text_at(journal, "Title"),
+        "year": year,
+        "issn": print_issn,
+        "eissn": electronic_issn,
+        "issn_linking": _text_at(journal_info, "ISSNLinking"),
+        "journal_abbrev": _text_at(journal, "ISOAbbreviation"),
+        "nlm_unique_id": _text_at(journal_info, "NlmUniqueID"),
+        "country": _text_at(journal_info, "Country"),
+        "volume": _text_at(journal, "JournalIssue/Volume"),
+        "issue": _text_at(journal, "JournalIssue/Issue"),
+        "pages": _text_at(article, "Pagination/MedlinePgn"),
+        "publication_date": publication_date,
+        "date_completed": _simple_date(citation.find("DateCompleted")),
+        "date_revised": _simple_date(citation.find("DateRevised")),
+        "citation_status": citation.attrib.get("Status"),
+        "publication_status": _text_at(pubmed_data, "PublicationStatus"),
+        "pub_model": article.attrib.get("PubModel") if article is not None else None,
+        "vernacular_title": _text_at(article, "VernacularTitle"),
+        "authors": authors,
+        "publication_types": _texts_at(article, "PublicationTypeList/PublicationType"),
+        "languages": _texts_at(article, "Language"),
+        "mesh_terms": mesh_terms,
+        "mesh_major_topics": mesh_major_topics,
+        "keywords": _unique(_texts_at(citation, "KeywordList/Keyword")),
+        "article_ids": _unique(flattened_ids),
+    }
+
+
+def _parse_book_article(element: ET.Element) -> Record:
+    document = element.find("BookDocument")
+    if document is None:
+        raise ValueError("PubmedBookArticle has no BookDocument")
+    book_data = element.find("PubmedBookData")
+    book = document.find("Book")
+
+    pmid = _text_at(document, "PMID")
+    if pmid is None:
+        raise ValueError("PubmedBookArticle has no PMID")
+
+    ids, flattened_ids = _article_ids(document, book_data)
+    year, publication_date = _publication_date(None, book_data, book=book)
+    authors = _authors(
+        document,
+        (
+            "AuthorList/Author",
+            "Book/AuthorList/Author",
+        ),
+    )
+
+    return {
+        "pmid": pmid,
+        "pmcid": (ids.get("pmc") or ids.get("pmcid") or [None])[0],
+        "doi": (ids.get("doi") or [None])[0],
+        "title": _text_at(document, "ArticleTitle") or _text_at(book, "BookTitle"),
+        "abstract": _abstract(document),
+        "journal": _text_at(book, "BookTitle"),
+        "year": year,
+        "issn": None,
+        "eissn": None,
+        "issn_linking": None,
+        "journal_abbrev": None,
+        "nlm_unique_id": None,
+        "country": _text_at(book, "Publisher/PublisherLocation"),
+        "volume": _text_at(book, "Volume"),
+        "issue": None,
+        "pages": _text_at(document, "Pagination/MedlinePgn"),
+        "publication_date": publication_date,
+        "date_completed": None,
+        "date_revised": _simple_date(document.find("DateRevised")),
+        "citation_status": "Book",
+        "publication_status": _text_at(book_data, "PublicationStatus"),
+        "pub_model": None,
+        "vernacular_title": _text_at(document, "VernacularTitle"),
+        "authors": authors,
+        "publication_types": _texts_at(document, "PublicationType"),
+        "languages": _texts_at(document, "Language"),
+        "mesh_terms": [],
+        "mesh_major_topics": [],
+        "keywords": _unique(_texts_at(document, "KeywordList/Keyword")),
+        "article_ids": flattened_ids,
+    }
+
+
+def _parse_record(element: ET.Element) -> Record:
+    if _local_name(element.tag) == "PubmedBookArticle":
+        return _parse_book_article(element)
+    return _parse_journal_article(element)
+
+
+def _record_pmid(element: ET.Element) -> str:
+    citation = element.find("MedlineCitation")
+    document = element.find("BookDocument")
+    pmid = _text_at(citation, "PMID") or _text_at(document, "PMID")
+    if pmid is None:
+        raise ValueError(f"{_local_name(element.tag)} has no PMID")
+    return pmid
+
+
+def _expected_md5(path: Path) -> str:
+    sidecar = path.with_name(f"{path.name}.md5")
+    try:
+        contents = sidecar.read_text().strip()
+    except FileNotFoundError as exc:
+        raise ValueError(f"Missing checksum sidecar: {sidecar}") from exc
+    match = re.search(r"\b([0-9a-fA-F]{32})\b", contents)
+    if match is None:
+        raise ValueError(f"Invalid MD5 sidecar: {sidecar}")
+    return match.group(1).casefold()
+
+
+def _verify_md5(path: Path) -> None:
+    expected = _expected_md5(path)
+    with path.open("rb") as file:
+        actual = hashlib.file_digest(file, "md5").hexdigest()
+    if actual != expected:
+        raise ValueError(f"MD5 mismatch for {path}: expected {expected}, got {actual}")
+
+
+def _iter_events(
+    path: Path,
+    *,
+    parse_records: bool,
+    verify_md5: bool,
+) -> Iterator[tuple[str, Record | None, bool]]:
+    if verify_md5:
+        _verify_md5(path)
+
+    with gzip.open(path, "rb") as file:
+        context = ET.iterparse(file, events=("start", "end"))
+        try:
+            _, root = next(context)
+        except StopIteration as exc:
+            raise ValueError(f"Empty XML file: {path}") from exc
+
+        for event, element in context:
+            if event != "end":
+                continue
+            tag = _local_name(element.tag)
+            if tag in {"PubmedArticle", "PubmedBookArticle"}:
+                record = _parse_record(element) if parse_records else None
+                pmid = record["pmid"] if record is not None else _record_pmid(element)
+                yield pmid, record, False
+                root.clear()
+            elif tag in {"DeleteCitation", "DeleteDocument"}:
+                for pmid_element in element.findall("PMID"):
+                    if pmid := _element_text(pmid_element):
+                        yield pmid, None, True
+                root.clear()
+
+
+def _event_key(file_index: int, event_index: int) -> int:
+    return (file_index << 32) | event_index
+
+
+def _index_update_file(task: tuple[int, Path, bool]) -> list[tuple[int, int, int]]:
+    file_index, path, verify_md5 = task
+    indexed: list[tuple[int, int, int]] = []
+    for event_index, (pmid, _, deleted) in enumerate(
+        _iter_events(path, parse_records=False, verify_md5=verify_md5),
+        start=1,
+    ):
+        indexed.append((int(pmid), _event_key(file_index, event_index), int(deleted)))
+    return indexed
+
+
+def _query_changed_pmids(connection: sqlite3.Connection, pmids: Sequence[int]) -> set[int]:
+    changed: set[int] = set()
+    for offset in range(0, len(pmids), SQLITE_QUERY_CHUNK):
+        chunk = pmids[offset : offset + SQLITE_QUERY_CHUNK]
+        placeholders = ",".join("?" for _ in chunk)
+        rows = connection.execute(f"SELECT pmid FROM latest_updates WHERE pmid IN ({placeholders})", chunk)
+        changed.update(row[0] for row in rows)
+    return changed
+
+
+def _query_latest_events(connection: sqlite3.Connection, pmids: Sequence[int]) -> dict[int, int]:
+    latest: dict[int, int] = {}
+    for offset in range(0, len(pmids), SQLITE_QUERY_CHUNK):
+        chunk = pmids[offset : offset + SQLITE_QUERY_CHUNK]
+        placeholders = ",".join("?" for _ in chunk)
+        rows = connection.execute(
+            f"SELECT pmid, event_key FROM latest_updates WHERE pmid IN ({placeholders})",
+            chunk,
+        )
+        latest.update(rows)
+    return latest
+
+
+def _read_only_connection(path: Path) -> sqlite3.Connection:
+    connection = sqlite3.connect(path)
+    connection.execute("PRAGMA query_only = ON")
+    return connection
+
+
+def _parse_baseline_file(task: tuple[Path, Path | None, bool]) -> ParsedFile:
+    path, state_db, verify_md5 = task
+    events = list(_iter_events(path, parse_records=True, verify_md5=verify_md5))
+    records = [record for _, record, _ in events if record is not None]
+    if state_db is not None and records:
+        connection = _read_only_connection(state_db)
+        try:
+            changed = _query_changed_pmids(connection, [int(record["pmid"]) for record in records])
+        finally:
+            connection.close()
+        records = [record for record in records if int(record["pmid"]) not in changed]
+    return ParsedFile(table=pa.Table.from_pylist(records, schema=PARQUET_SCHEMA), event_count=len(events))
+
+
+def _parse_update_file(task: tuple[int, Path, Path]) -> ParsedFile:
+    file_index, path, state_db = task
+    events = list(_iter_events(path, parse_records=True, verify_md5=False))
+    connection = _read_only_connection(state_db)
+    try:
+        latest = _query_latest_events(connection, [int(pmid) for pmid, _, _ in events])
+    finally:
+        connection.close()
+
+    records: list[Record] = [
+        record
+        for event_index, (pmid, record, _) in enumerate(events, start=1)
+        if record is not None and latest.get(int(pmid)) == _event_key(file_index, event_index)
+    ]
+    return ParsedFile(table=pa.Table.from_pylist(records, schema=PARQUET_SCHEMA), event_count=len(events))
+
+
+def _ordered_process_map[Task, Result](
+    function: Callable[[Task], Result],
+    tasks: Iterable[Task],
+    *,
+    workers: int,
+) -> Iterator[Result]:
+    if workers == 1:
+        yield from map(function, tasks)
+        return
+
+    task_iterator = iter(tasks)
+    with concurrent.futures.ProcessPoolExecutor(max_workers=workers) as executor:
+        pending: deque[concurrent.futures.Future[Result]] = deque()
+        for _ in range(workers):
+            try:
+                pending.append(executor.submit(function, next(task_iterator)))
+            except StopIteration:
+                break
+
+        while pending:
+            yield pending.popleft().result()
+            with contextlib.suppress(StopIteration):
+                pending.append(executor.submit(function, next(task_iterator)))
+
+
+def _discover_files(directory: Path) -> list[DistributionFile]:
+    files: list[DistributionFile] = []
+    for path in directory.glob("pubmed*n*.xml.gz"):
+        if match := FILE_RE.fullmatch(path.name):
+            files.append(
+                DistributionFile(
+                    path=path,
+                    release=int(match.group("release")),
+                    sequence=int(match.group("sequence")),
+                )
+            )
+    return sorted(files, key=lambda item: (item.release, item.sequence))
+
+
+def _assert_contiguous(files: Sequence[DistributionFile], label: str) -> None:
+    for previous, current in zip(files, files[1:], strict=False):
+        if current.release != previous.release or current.sequence != previous.sequence + 1:
+            raise ValueError(f"{label} files are not contiguous between {previous.path.name} and {current.path.name}")
+
+
+def discover_distribution(
+    input_root: Path, *, baseline_only: bool
+) -> tuple[list[DistributionFile], list[DistributionFile]]:
+    baseline = _discover_files(input_root / "baseline")
+    updates = [] if baseline_only else _discover_files(input_root / "updatefiles")
+    if not baseline:
+        raise ValueError(f"No PubMed baseline XML files found in {input_root / 'baseline'}")
+    if baseline[0].sequence != 1:
+        raise ValueError(f"The baseline starts at {baseline[0].path.name}, not sequence 0001")
+    _assert_contiguous(baseline, "Baseline")
+    _assert_contiguous(updates, "Update")
+
+    if updates:
+        expected_first_update = baseline[-1].sequence + 1
+        if updates[0].release != baseline[-1].release or updates[0].sequence != expected_first_update:
+            raise ValueError(
+                f"Expected the first update after {baseline[-1].path.name} to have sequence "
+                f"{expected_first_update:04d}, found {updates[0].path.name}"
+            )
+    return baseline, updates
+
+
+def _build_update_index(
+    update_files: Sequence[DistributionFile],
+    state_db: Path,
+    *,
+    workers: int,
+    verify_md5: bool,
+) -> tuple[int, int, int]:
+    with sqlite3.connect(state_db) as connection:
+        connection.execute("PRAGMA journal_mode = OFF")
+        connection.execute("PRAGMA synchronous = OFF")
+        connection.execute(
+            """
+            CREATE TABLE latest_updates (
+                pmid INTEGER PRIMARY KEY,
+                event_key INTEGER NOT NULL,
+                deleted INTEGER NOT NULL
+            )
+            """
+        )
+        tasks = ((index, item.path, verify_md5) for index, item in enumerate(update_files))
+        total_events = 0
+        results = _ordered_process_map(_index_update_file, tasks, workers=workers)
+        for indexed in tqdm(results, total=len(update_files), desc="Index updates", unit="file"):
+            total_events += len(indexed)
+            connection.executemany(
+                """
+                INSERT INTO latest_updates (pmid, event_key, deleted)
+                VALUES (?, ?, ?)
+                ON CONFLICT(pmid) DO UPDATE SET
+                    event_key = excluded.event_key,
+                    deleted = excluded.deleted
+                WHERE excluded.event_key > latest_updates.event_key
+                """,
+                indexed,
+            )
+            connection.commit()
+        counts = connection.execute("SELECT count(), coalesce(sum(deleted), 0) FROM latest_updates").fetchone()
+        assert counts is not None
+        latest_events, latest_deletions = counts
+    return total_events, latest_events, latest_deletions
+
+
+def _parquet_schema(baseline: Sequence[DistributionFile], updates: Sequence[DistributionFile]) -> pa.Schema:
+    metadata = {
+        b"source": b"NLM PubMed baseline and daily update XML",
+        b"pubmed_release": str(baseline[0].release).encode(),
+        b"baseline_first_file": baseline[0].path.name.encode(),
+        b"baseline_last_file": baseline[-1].path.name.encode(),
+        b"update_last_file": (updates[-1].path.name if updates else "").encode(),
+    }
+    return PARQUET_SCHEMA.with_metadata(metadata)
+
+
+def build_parquet(
+    input_root: Path,
+    output: Path,
+    *,
+    workers: int = DEFAULT_WORKERS,
+    baseline_only: bool = False,
+    verify_md5: bool = True,
+    overwrite: bool = False,
+    compression_level: int = 3,
+) -> None:
+    """Build one Parquet file containing the final live version of each PMID."""
+    if workers < 1:
+        raise ValueError("workers must be at least 1")
+    if output.exists() and not overwrite:
+        raise FileExistsError(f"Output exists; pass --overwrite to replace it: {output}")
+
+    baseline, updates = discover_distribution(input_root, baseline_only=baseline_only)
+    print(
+        f"Found {len(baseline):,} baseline files"
+        + (f" and {len(updates):,} update files" if updates else " (baseline only)")
+    )
+    output.parent.mkdir(parents=True, exist_ok=True)
+    partial_output = output.with_name(f".{output.name}.partial")
+    if partial_output.exists():
+        if not overwrite:
+            raise FileExistsError(f"Partial output exists; pass --overwrite to replace it: {partial_output}")
+        partial_output.unlink()
+
+    total_input_events = 0
+    total_output_rows = 0
+    update_event_count = 0
+    latest_update_count = 0
+    latest_deletion_count = 0
+    try:
+        with tempfile.TemporaryDirectory(prefix="pubmed-parquet-", dir=output.parent) as temp_dir:
+            state_db = Path(temp_dir) / "latest_updates.sqlite3"
+            state_db_or_none: Path | None = None
+            if updates:
+                update_event_count, latest_update_count, latest_deletion_count = _build_update_index(
+                    updates,
+                    state_db,
+                    workers=workers,
+                    verify_md5=verify_md5,
+                )
+                state_db_or_none = state_db
+
+            schema = _parquet_schema(baseline, updates)
+            with pq.ParquetWriter(
+                partial_output,
+                schema,
+                compression="zstd",
+                compression_level=compression_level,
+                use_dictionary=[
+                    "journal",
+                    "year",
+                    "country",
+                    "citation_status",
+                    "publication_status",
+                    "pub_model",
+                ],
+                write_statistics=["pmid", "pmcid", "doi", "journal", "year"],
+            ) as writer:
+                baseline_tasks = ((item.path, state_db_or_none, verify_md5) for item in baseline)
+                baseline_results = _ordered_process_map(_parse_baseline_file, baseline_tasks, workers=workers)
+                for parsed in tqdm(baseline_results, total=len(baseline), desc="Write baseline", unit="file"):
+                    total_input_events += parsed.event_count
+                    if parsed.table.num_rows:
+                        writer.write_table(parsed.table)
+                        total_output_rows += parsed.table.num_rows
+
+                if updates:
+                    update_tasks = ((index, item.path, state_db) for index, item in enumerate(updates))
+                    update_results = _ordered_process_map(_parse_update_file, update_tasks, workers=workers)
+                    for parsed in tqdm(update_results, total=len(updates), desc="Write updates", unit="file"):
+                        if parsed.table.num_rows:
+                            writer.write_table(parsed.table)
+                            total_output_rows += parsed.table.num_rows
+
+        partial_output.replace(output)
+    except BaseException:
+        partial_output.unlink(missing_ok=True)
+        raise
+
+    print(f"Wrote {total_output_rows:,} current PubMed records to {output}")
+    print(f"Read {total_input_events:,} baseline records")
+    if updates:
+        print(
+            f"Processed {update_event_count:,} update events affecting {latest_update_count:,} PMIDs "
+            f"({latest_deletion_count:,} deleted in their latest event)"
+        )
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--input-root",
+        type=Path,
+        default=DEFAULT_INPUT_ROOT,
+        help=f"Directory containing baseline/ and updatefiles/ (default: {DEFAULT_INPUT_ROOT})",
+    )
+    parser.add_argument("--output", type=Path, required=True, help="Destination .parquet file")
+    parser.add_argument(
+        "--workers", type=int, default=DEFAULT_WORKERS, help=f"Parser processes (default: {DEFAULT_WORKERS})"
+    )
+    parser.add_argument("--baseline-only", action="store_true", help="Ignore daily update files")
+    parser.add_argument("--skip-md5", action="store_true", help="Do not validate mirrored files against .md5 sidecars")
+    parser.add_argument("--overwrite", action="store_true", help="Atomically replace an existing output file")
+    parser.add_argument("--compression-level", type=int, default=3, help="Zstandard compression level (default: 3)")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+    build_parquet(
+        args.input_root,
+        args.output,
+        workers=args.workers,
+        baseline_only=args.baseline_only,
+        verify_md5=not args.skip_md5,
+        overwrite=args.overwrite,
+        compression_level=args.compression_level,
+    )
+
+
+if __name__ == "__main__":
+    main()