| """Download the raw source records for every compound in ``compounds_list.py`` into ``references/spectral_raw/<id>/``. |
| |
| Sources (all public web services, fetched politely with a delay and cached; re-runs skip files already on disk): |
| |
| * NIST Chemistry WebBook (https://webbook.nist.gov), keyed by CAS: |
| gc.html Mask=2000 Kovats / Van den Dool retention-index tables (nonpolar + polar columns) |
| thermo.html Mask=4 phase-change data (boiling point, enthalpy of vaporization) |
| ir.html Mask=80 list of available IR spectra; each is then saved as ir_<index>.jdx (JCAMP-DX) |
| uv.html Mask=400 list of UV/Vis spectra; each saved as uv_<index>.jdx |
| ms_0.jdx Type=Mass NIST/EPA/NIH electron-ionisation mass spectrum (peak list) |
| * PubChem (https://pubchem.ncbi.nlm.nih.gov), keyed by CAS via the name resolver: |
| pubchem_props.json CID, formula, MW, SMILES, XLogP, IUPAC name |
| pubchem_nmr_1h.json PUG-View section "1H NMR Spectra" (HMDB peak lists re-hosted by PubChem) |
| pubchem_nmr_13c.json PUG-View section "13C NMR Spectra" |
| pubchem_uv.json PUG-View section "UV Spectra" (lambda-max text records) |
| |
| Usage: python fetch_sources.py [--ids a,b,c] [--delay 0.6] [--force] [--skip-unlisted] |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| import sys |
| import time |
| from pathlib import Path |
|
|
| import requests |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| from compounds_list import COMPOUNDS |
|
|
| ROOT = Path(__file__).resolve().parents[2] |
| RAW = ROOT / "references" / "spectral_raw" |
| NIST = "https://webbook.nist.gov/cgi/cbook.cgi" |
| PUBCHEM = "https://pubchem.ncbi.nlm.nih.gov/rest" |
| HEADERS = {"User-Agent": "Chemistry-Sim spectral-library fetcher (academic lab simulator; contact: project maintainer)"} |
| MAX_SPECTRA_PER_TYPE = 4 |
|
|
|
|
| def nist_id(cas: str) -> str: |
| return "C" + cas.replace("-", "") |
|
|
|
|
| def get(session: requests.Session, url: str, params: dict | None, dest: Path, delay: float, force: bool, log) -> bytes | None: |
| if dest.exists() and not force: |
| return dest.read_bytes() |
| for attempt in range(3): |
| try: |
| r = session.get(url, params=params, headers=HEADERS, timeout=60) |
| time.sleep(delay) |
| if r.status_code == 200: |
| dest.write_bytes(r.content) |
| return r.content |
| if r.status_code in (404,): |
| dest.write_bytes(b"") |
| return b"" |
| log(f" HTTP {r.status_code} for {r.url}; retry {attempt + 1}") |
| except requests.RequestException as exc: |
| log(f" {exc!r}; retry {attempt + 1}") |
| time.sleep(3.0 * (attempt + 1)) |
| return None |
|
|
|
|
| def nist_listed_masks(page: bytes) -> set[str]: |
| """Masks of the data sections a NIST WebBook compound page links to ('Other data available'), e.g. {'4', '80', '200'}.""" |
| if b"Registry Number Not Found" in page or b'<h1 id="Top">' not in page: |
| return set() |
| return {m.decode() for m in re.findall(rb"Mask=([0-9A-F]+)#", page)} |
|
|
|
|
| def jcamp_ok(blob: bytes | None) -> bool: |
| return bool(blob) and b"Spectrum not found" not in blob[:200] and b"##XYDATA" in blob or (bool(blob) and b"##PEAK TABLE" in blob) |
|
|
|
|
| def fetch_compound(session, row, delay, force, log, skip_unlisted=False): |
| sid, name_en, name_zh, cas, cls = row |
| d = RAW / sid |
| d.mkdir(parents=True, exist_ok=True) |
| cid = nist_id(cas) |
| |
| gc_page = get(session, NIST, {"ID": cid, "Mask": "2000", "Units": "SI"}, d / "gc.html", delay, force, log) or b"" |
| listed = nist_listed_masks(gc_page) if skip_unlisted and gc_page else None |
|
|
| def wanted(mask: str, dest: Path) -> bool: |
| """With --skip-unlisted, do not request data NIST's own 'Other data available' list says it does not hold.""" |
| if listed is None or mask in listed or dest.exists(): |
| return True |
| log(f" skip {dest.name}: Mask={mask} not listed on the NIST page") |
| return False |
|
|
| if wanted("4", d / "thermo.html"): |
| get(session, NIST, {"ID": cid, "Mask": "4", "Units": "SI"}, d / "thermo.html", delay, force, log) |
| ir_page = (get(session, NIST, {"ID": cid, "Mask": "80", "Units": "SI"}, d / "ir.html", delay, force, log) or b"") if wanted("80", d / "ir.html") else b"" |
| uv_page = (get(session, NIST, {"ID": cid, "Mask": "400", "Units": "SI"}, d / "uv.html", delay, force, log) or b"") if wanted("400", d / "uv.html") else b"" |
| for kind, page, typ in (("ir", ir_page, "IR"), ("uv", uv_page, "UVVis")): |
| indices = sorted({int(m) for m in re.findall(rb"Index=(\d+)", page)})[:MAX_SPECTRA_PER_TYPE] |
| for idx in indices: |
| get(session, NIST, {"JCAMP": cid, "Index": str(idx), "Type": typ}, d / f"{kind}_{idx}.jdx", delay, force, log) |
| if wanted("200", d / "ms_0.jdx"): |
| get(session, NIST, {"JCAMP": cid, "Index": "0", "Type": "Mass"}, d / "ms_0.jdx", delay, force, log) |
| |
| props = "MolecularFormula,MolecularWeight,SMILES,ConnectivitySMILES,XLogP,IUPACName,Title" |
| blob = get(session, f"{PUBCHEM}/pug/compound/name/{cas}/property/{props}/JSON", None, d / "pubchem_props.json", delay, force, log) |
| pc_cid = None |
| try: |
| pc_cid = json.loads(blob)["PropertyTable"]["Properties"][0]["CID"] |
| except Exception: |
| |
| blob = get(session, f"{PUBCHEM}/pug/compound/name/{name_en}/property/{props}/JSON", None, d / "pubchem_props.json", delay, True, log) |
| try: |
| pc_cid = json.loads(blob)["PropertyTable"]["Properties"][0]["CID"] |
| except Exception: |
| log(f" PubChem: no CID for {sid} ({cas} / {name_en})") |
| if pc_cid: |
| for heading, fname in (("1H NMR Spectra", "pubchem_nmr_1h.json"), ("13C NMR Spectra", "pubchem_nmr_13c.json"), ("UV Spectra", "pubchem_uv.json")): |
| get(session, f"{PUBCHEM}/pug_view/data/compound/{pc_cid}/JSON", {"heading": heading}, d / fname, delay, force, log) |
| have = sorted(p.name for p in d.iterdir() if p.stat().st_size > 0) |
| log(f" {sid}: {len(have)} files ({', '.join(n for n in have if n.endswith('.jdx'))})") |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--ids", default="", help="comma-separated subset of substance ids") |
| ap.add_argument("--delay", type=float, default=0.6, help="seconds to wait after every request") |
| ap.add_argument("--force", action="store_true", help="re-download files already cached") |
| ap.add_argument("--skip-unlisted", action="store_true", |
| help="skip thermo/IR/UV/MS requests for data types the compound's NIST page (gc.html) does not list (fewer requests; same result)") |
| args = ap.parse_args() |
| rows = COMPOUNDS if not args.ids else [r for r in COMPOUNDS if r[0] in set(args.ids.split(","))] |
| RAW.mkdir(parents=True, exist_ok=True) |
| log_path = RAW / "fetch_log.txt" |
| with open(log_path, "a", encoding="utf-8") as lf: |
| def log(msg): |
| print(msg, flush=True) |
| lf.write(msg + "\n"); lf.flush() |
| log(f"=== fetch {time.strftime('%Y-%m-%d %H:%M:%S')}: {len(rows)} compounds") |
| with requests.Session() as session: |
| for i, row in enumerate(rows, 1): |
| log(f"[{i}/{len(rows)}] {row[0]} ({row[3]})") |
| try: |
| fetch_compound(session, row, args.delay, args.force, log, skip_unlisted=args.skip_unlisted) |
| except Exception as exc: |
| log(f" FAILED {row[0]}: {exc!r}") |
| log("=== done") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
