Upload folder using huggingface_hub

README_SERVER.md

@@ -0,0 +1,112 @@
+# Portable rDock Pipeline
+
+## List known-good PDB complexes
+```bash
+python scripts/prepare_pdb_ligand_dataset.py --list-known-good
+```
+
+## Inspect hetero ligands for a PDB
+```bash
+python scripts/prepare_pdb_ligand_dataset.py \
+  --list-hetero \
+  --pdb-id 1A52
+```
+
+For `1A52`, the parser should confirm that the correct reference ligand is `EST`, not `MK1`. `AU` is treated as an ion/metal and ignored as a docking reference ligand.
+
+## Prepare a dataset for one PDB complex
+```bash
+python scripts/prepare_pdb_ligand_dataset.py \
+  --pdb-id 4HG7 \
+  --receptor-chain A \
+  --reference-ligand-resname NUT \
+  --reference-ligand-chain A \
+  --n-ligands 1000 \
+  --ligand-source smiles_file \
+  --smiles-file data/examples/example_smiles_1000.smi \
+  --out /data/datasets/rdock_4hg7_1000 \
+  --force
+```
+
+## Auto-detect the reference ligand
+```bash
+python scripts/prepare_pdb_ligand_dataset.py \
+  --pdb-id 1A52 \
+  --receptor-chain A \
+  --auto-reference-ligand \
+  --n-ligands 1000 \
+  --ligand-source smiles_file \
+  --smiles-file data/examples/example_smiles_1000.smi \
+  --out /data/datasets/rdock_1a52_1000 \
+  --force
+```
+
+## Validate an existing dataset directory
+```bash
+python scripts/prepare_pdb_ligand_dataset.py \
+  --validate-only \
+  --out /data/datasets/rdock_4hg7_1000
+```
+
+or
+
+```bash
+python -m docking_pipeline validate-dataset \
+  --dataset-dir /data/datasets/rdock_4hg7_1000
+```
+
+## Prepare a real 1000-SMILES example file
+```bash
+python scripts/download_example_smiles.py \
+  --n 1000 \
+  --out data/examples/example_smiles_1000.smi
+```
+
+This file contains real compounds derived from the benchmark ligand library already present in this repository. It is not a synthetic or random SMILES set.
+
+## Large libraries
+For large libraries such as `50000` ligands, use a real SMILES file:
+
+```bash
+python scripts/prepare_pdb_ligand_dataset.py \
+  --pdb-id 1A52 \
+  --receptor-chain A \
+  --auto-reference-ligand \
+  --n-ligands 50000 \
+  --ligand-source smiles_file \
+  --smiles-file /data/libraries/real_50k_library.smi \
+  --out /data/datasets/rdock_1a52_50k \
+  --force
+```
+
+`PubChem similarity` may fail to collect 1000 analogs for some reference ligands. When that happens, the generator writes `logs/pubchem_diagnostics.json` and you should switch to `--ligand-source smiles_file`.
+
+## Run multi-fidelity docking
+```bash
+python -m docking_pipeline benchmark-adaptive \
+  --dataset-dir /data/datasets/rdock_1a52_50k \
+  --strategy multifidelity_adaptive_rdock \
+  --fidelity-levels 5,10,15,30,50 \
+  --cost-budget-runs 250000 \
+  --jobs auto \
+  --cpu-fraction 0.85 \
+  --out /data/results/rdock_1a52_50k_mf \
+  --resume
+```
+
+## Results layout
+- `target/`, `ligands/`, `rdock/`, `poses/`, `tables/`, `metrics/`, `plots/`, `checkpoints/`
+- `report.md`, `manifest.json`, `config.yaml`, `commands.log`
+
+## Resume
+- Re-run the same `benchmark-adaptive` command with `--resume`.
+- Checkpoints are written under `checkpoints/`.
+
+## Output interpretation
+- `full_docking_scores.csv`: exhaustive final-fidelity docking reference.
+- `random_baseline_scores.csv`: random baseline at matched cost budget.
+- `single_fidelity_adaptive_scores.csv`: direct final-fidelity model-priority comparator.
+- `multifidelity_trace.csv`: per-ligand trace across fidelity levels.
+- `promotion_decisions.csv`: promotion and rejection reasons.
+- `final_hits.csv`: hit table after multi-fidelity promotion logic.
+- `adaptive_benchmark_metrics.json`: aggregate benchmark metrics and cost accounting.

check_environment.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "python: $(command -v python || true)"
+echo "rbdock: $(command -v rbdock || true)"
+echo "rbcavity: $(command -v rbcavity || true)"
+echo "obabel: $(command -v obabel || true)"
+
+python - <<'PY'
+import importlib
+import importlib.util
+
+mods = ["yaml", "pandas", "matplotlib", "rdkit"]
+for name in mods:
+    print(f"{name}: {'ok' if importlib.util.find_spec(name) else 'missing'}")
+PY
+
+python -m docking_pipeline --help >/dev/null
+python scripts/prepare_pdb_ligand_dataset.py --help >/dev/null
+
+echo "Environment check completed."

configs/known_good_pdb_complexes.yaml

@@ -0,0 +1,137 @@
+{
+  "complexes": [
+    {
+      "pdb_id": "4HG7",
+      "target_name": "MDM2",
+      "receptor_chain": "A",
+      "reference_ligand_resname": "NUT",
+      "reference_ligand_chain": "A",
+      "available_hetero_ligands": [
+        {"resname": "NUT", "chain": "A", "residue_id": "201", "atom_count": 40, "candidate_ligand": true}
+      ],
+      "checked_download": true,
+      "checked_parse": true,
+      "checked_reference_ligand": true,
+      "notes": "Local parser check confirmed NUT chain A as the reference ligand."
+    },
+    {
+      "pdb_id": "4WKQ",
+      "target_name": "EGFR",
+      "receptor_chain": "A",
+      "reference_ligand_resname": "IRE",
+      "reference_ligand_chain": "A",
+      "available_hetero_ligands": [
+        {"resname": "IRE", "chain": "A", "residue_id": "1101", "atom_count": 31, "candidate_ligand": true}
+      ],
+      "checked_download": true,
+      "checked_parse": true,
+      "checked_reference_ligand": true,
+      "notes": "Local parser check confirmed IRE chain A."
+    },
+    {
+      "pdb_id": "1IEP",
+      "target_name": "ABL1",
+      "receptor_chain": "A",
+      "reference_ligand_resname": "STI",
+      "reference_ligand_chain": "A",
+      "available_hetero_ligands": [
+        {"resname": "STI", "chain": "A", "residue_id": "201", "atom_count": 37, "candidate_ligand": true},
+        {"resname": "STI", "chain": "B", "residue_id": "202", "atom_count": 37, "candidate_ligand": true}
+      ],
+      "checked_download": true,
+      "checked_parse": true,
+      "checked_reference_ligand": true,
+      "notes": "Use chain A unless the alternate biological assembly is explicitly desired."
+    },
+    {
+      "pdb_id": "1A52",
+      "target_name": "Estrogen receptor alpha",
+      "receptor_chain": "A",
+      "reference_ligand_resname": "EST",
+      "reference_ligand_chain": "A",
+      "available_hetero_ligands": [
+        {"resname": "EST", "chain": "A", "residue_id": "1", "atom_count": 20, "candidate_ligand": true},
+        {"resname": "EST", "chain": "B", "residue_id": "2", "atom_count": 20, "candidate_ligand": true},
+        {"resname": "AU", "chain": "A", "residue_id": "265", "atom_count": 3, "candidate_ligand": false},
+        {"resname": "AU", "chain": "B", "residue_id": "266", "atom_count": 3, "candidate_ligand": false}
+      ],
+      "checked_download": true,
+      "checked_parse": true,
+      "checked_reference_ligand": true,
+      "notes": "Correct reference ligand is EST, not MK1. AU entries are ignored as ions/metals."
+    },
+    {
+      "pdb_id": "1T46",
+      "target_name": "ABL1 alternative complex",
+      "receptor_chain": "A",
+      "reference_ligand_resname": "STI",
+      "reference_ligand_chain": "A",
+      "available_hetero_ligands": [
+        {"resname": "STI", "chain": "A", "residue_id": "3", "atom_count": 37, "candidate_ligand": true}
+      ],
+      "checked_download": true,
+      "checked_parse": true,
+      "checked_reference_ligand": true,
+      "notes": "Single clear STI ligand in chain A."
+    },
+    {
+      "pdb_id": "3PTB",
+      "target_name": "Trypsin",
+      "receptor_chain": "A",
+      "reference_ligand_resname": "BEN",
+      "reference_ligand_chain": "A",
+      "available_hetero_ligands": [
+        {"resname": "BEN", "chain": "A", "residue_id": "1", "atom_count": 9, "candidate_ligand": true}
+      ],
+      "checked_download": true,
+      "checked_parse": true,
+      "checked_reference_ligand": true,
+      "notes": "Compact benchmark target with benzamidine."
+    },
+    {
+      "pdb_id": "2HYY",
+      "target_name": "ABL1 tetrameric assembly",
+      "receptor_chain": "A",
+      "reference_ligand_resname": "STI",
+      "reference_ligand_chain": "A",
+      "available_hetero_ligands": [
+        {"resname": "STI", "chain": "A", "residue_id": "600", "atom_count": 37, "candidate_ligand": true},
+        {"resname": "STI", "chain": "B", "residue_id": "600", "atom_count": 37, "candidate_ligand": true},
+        {"resname": "STI", "chain": "C", "residue_id": "600", "atom_count": 37, "candidate_ligand": true},
+        {"resname": "STI", "chain": "D", "residue_id": "600", "atom_count": 37, "candidate_ligand": true}
+      ],
+      "checked_download": true,
+      "checked_parse": true,
+      "checked_reference_ligand": true,
+      "notes": "Tetrameric structure; chain A is the default receptor chain for the portable pipeline."
+    },
+    {
+      "pdb_id": "1HSG",
+      "target_name": "HIV protease",
+      "receptor_chain": "A,B",
+      "reference_ligand_resname": "MK1",
+      "reference_ligand_chain": "B",
+      "available_hetero_ligands": [
+        {"resname": "MK1", "chain": "B", "residue_id": "902", "atom_count": 45, "candidate_ligand": true}
+      ],
+      "checked_download": true,
+      "checked_parse": true,
+      "checked_reference_ligand": true,
+      "notes": "Validated locally as a multi-chain receptor target with one clear ligand."
+    },
+    {
+      "pdb_id": "1HVR",
+      "target_name": "HIV reverse transcriptase",
+      "receptor_chain": "A",
+      "reference_ligand_resname": "XK2",
+      "reference_ligand_chain": "A",
+      "available_hetero_ligands": [
+        {"resname": "XK2", "chain": "A", "residue_id": "263", "atom_count": 46, "candidate_ligand": true}
+      ],
+      "checked_download": true,
+      "checked_parse": true,
+      "checked_reference_ligand": true,
+      "notes": "Validated locally as a single-chain receptor with one clear organic ligand."
+    }
+  ]
+}

configs/multifidelity_defaults.yaml

@@ -0,0 +1,14 @@
+{
+  "strategy": "multifidelity_adaptive_rdock",
+  "fidelity_levels": [5, 10, 15, 30, 50],
+  "cost_budget_runs": 12500,
+  "promotion_fraction": 0.5,
+  "min_per_cluster": 1,
+  "max_per_cluster": 50,
+  "outlier_intra_z_threshold": 3.0,
+  "score_component_filter": "warn",
+  "final_fidelity_only_hits": true,
+  "jobs": "auto",
+  "cpu_fraction": 0.85,
+  "checkpoint_every": 1
+}

data/examples/example_pdb_dataset_config.yaml

@@ -0,0 +1,9 @@
+{
+  "pdb_id": "4HG7",
+  "receptor_chain": "A",
+  "reference_ligand_resname": "NUT",
+  "reference_ligand_chain": "A",
+  "n_ligands": 50,
+  "smiles_file": "data/examples/example_smiles.smi",
+  "ligand_source": "bundled_or_remote"
+}

data/examples/example_smiles.smi

@@ -0,0 +1,50 @@
+CCO ethanol
+CCN ethylamine
+CCC propane
+CCCO propanol
+CCCC butane
+CC(=O)O acetic_acid
+CCOC ethoxyethane
+c1ccccc1 benzene
+Cc1ccccc1 toluene
+Oc1ccccc1 phenol
+Nc1ccccc1 aniline
+CC(=O)N acetamide
+CC(C)O isopropanol
+CC(C)N isopropylamine
+C1CCCCC1 cyclohexane
+C1CCNCC1 piperidine
+c1ccncc1 pyridine
+c1ccoc1 furan
+c1ccsc1 thiophene
+CCS ethanethiol
+COC dimethyl_ether
+CCCl chloroethane
+CCBr bromoethane
+CC#N acetonitrile
+CC(=O)OC methyl_acetate
+CC(C)(C)O tert_butanol
+CC(C)(C)N tert_butylamine
+CC(C)C isobutane
+CC(C)CO isobutanol
+CC(C)C(=O)O isobutyric_acid
+c1ccc(F)cc1 fluorobenzene
+c1ccc(Cl)cc1 chlorobenzene
+c1ccc(Br)cc1 bromobenzene
+COc1ccccc1 anisole
+CCOc1ccccc1 ethoxybenzene
+CCc1ccccc1 ethylbenzene
+CC(=O)c1ccccc1 acetophenone
+O=C(O)c1ccccc1 benzoic_acid
+NC(=O)c1ccccc1 benzamide
+CCN(CC)CC triethylamine
+CCOCCO diethylene_glycol
+NCCO ethanolamine
+OCCO ethylene_glycol
+CC(C)COC isobutyl_methyl_ether
+CC(C)CC isoamyl
+CC(C)(C)C neopentane
+CNC methylamine
+CN(C)C trimethylamine
+CC(C)=O acetone
+CCOC(=O)C ethyl_acetate

data/examples/example_smiles_1000.smi

@@ -0,0 +1,1000 @@
+Cc1nc2ccccc2n1CC(C)(C)c1cc(C(F)(F)F)cc(C(F)(F)F)c1 ref_nutlin3a_prelim
+Cc1nc2ccccc2n1CC(F)(F)F lb_00001
+Cc1nc2ccccc2n1Cc1cccc(C(F)(F)F)c1 lb_00002
+Cc1nc2ccccc2n1-c1cc(C(F)(F)F)cc(C(F)(F)F)c1 lb_00003
+Cc1nc2ccccc2n1Cc1ccccc1C(F)(F)F lb_00004
+FC(F)(F)c1cc(-c2nc3ccccc3n2Cc2ccccc2)cc(C(F)(F)F)c1 lb_00005
+Cn1c(-c2cc(C(F)(F)F)cc(C(F)(F)F)c2)nc2ccccc21 lb_00006
+Cc1nc2ccc(C(F)(F)F)cc2n1CCc1ccccc1 lb_00007
+Cc1nc2cc(C(F)(F)F)ccc2n1Cc1ccccc1 lb_00008
+CCCn1c(-c2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00009
+CCn1c(-c2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00010
+CCn1c(C)nc2cc(C(F)(F)F)ccc21 lb_00011
+Cc1nc2ccccc2n1CCC(=O)Nc1cccc(C(F)(F)F)c1 lb_00012
+CCCCn1c(-c2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00013
+CC(C)n1c(-c2cc(C(F)(F)F)cc(C(F)(F)F)c2)nc2ccccc21 lb_00014
+Cc1nc2ccccc2n1CCCCN1CCN(c2cccc(C(F)(F)F)c2)CC1 lb_00015
+Cc1nc2ccccc2n1Cc1cccc(CC(C)(C)C)c1 lb_00016
+Cc1nc2ccccc2n1-c1ccc(C(F)(F)F)cc1C(F)(F)F lb_00017
+Cc1nc2ccccc2n1Cc1ccccc1 lb_00018
+Cc1nc2ccccc2n1CCCCN1CCN(c2cccc(C(F)(F)F)c2)CC1.Cl lb_00019
+Cc1nc2ccccc2n1CC1CCN(Cc2cccc(C(F)(F)F)c2)CC1 lb_00020
+Cc1nc2ccccc2n1CC1CCN(Cc2ccc(C(F)(F)F)cc2)CC1 lb_00021
+CCCCCCn1c(-c2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00022
+Cc1ccc(-c2nc3ccccc3n2CCc2cccc(C(F)(F)F)c2)cc1 lb_00023
+Cc1cc(Cn2c(C(F)(F)F)nc3ccccc32)c(C)cc1Cn1c(C(F)(F)F)nc2ccccc21 lb_00024
+Cc1nc2ccccc2n1Cc1cccc(F)c1 lb_00025
+Cc1nc2ccccc2n1Cc1c(F)cccc1F lb_00026
+Cc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00027
+Cc1nc2ccccc2n1Cc1ccccc1F lb_00028
+Cc1cc(C)c(C)c(Cn2c(C)nc3ccccc32)c1C lb_00029
+Cc1nc2ccccc2n1CCc1ccccc1 lb_00030
+CCCCn1c(C)nc2ccccc21 lb_00031
+CCn1c(C(F)(F)F)nc2ccccc21 lb_00032
+Cc1cc(C)c(-c2nc3ccccc3n2CC(F)(F)F)c(C)c1 lb_00033
+FC(F)(F)c1ccc(Cn2c(-c3ccc(C(F)(F)F)cc3)nc3ccccc32)cc1 lb_00034
+CNc1nc2ccccc2n1-c1cc(C(F)(F)F)cc(C(F)(F)F)c1 lb_00035
+CC(C)c1nc2ccccc2n1-c1cc(C(F)(F)F)cc(C(F)(F)F)c1 lb_00036
+Cc1nc2ccccc2n1Cc1ccc2ccccc2c1 lb_00037
+Cc1cccc(Cn2c(C)nc3ccccc32)c1 lb_00038
+Cc1ccccc1Cn1c(C)nc2ccccc21 lb_00039
+Cc1ccc(Cn2c(C)nc3ccccc32)cc1 lb_00040
+Cc1nc2ccccc2n1CCC(C)C lb_00041
+Cc1ccc(Cn2c(-c3cccc(C(F)(F)F)c3)nc3ccccc32)cc1 lb_00042
+Cc1ccc(Cn2c(-c3ccc(C(F)(F)F)cc3)nc3ccccc32)cc1 lb_00043
+CC(C)(C)c1ccc(Cn2c(C(F)(F)F)nc3ccccc32)cc1 lb_00044
+Cc1cc(C)c(C)c(Cn2c(C(F)(F)F)nc3ccccc32)c1C lb_00045
+Cc1cc(C)c(Cn2c(C(F)(F)F)nc3ccccc32)c(C)c1 lb_00046
+FC(F)(F)c1cccc(Cn2c(C(F)(F)F)nc3ccccc32)c1 lb_00047
+FC(F)(F)c1ccc(Cn2c(-c3ccccc3)nc3ccccc32)cc1 lb_00048
+FC(F)(F)c1ccc(-c2nc3ccccc3n2Cc2ccccc2)cc1 lb_00049
+CC(C)(C)c1cc(Cn2c(-c3cc(C(C)(C)C)cc(C(C)(C)C)c3)nc3ccccc32)cc(C(C)(C)C)c1 lb_00050
+Cn1c(N=Nc2cc(C(F)(F)F)cc(C(F)(F)F)c2)nc2ccccc21 lb_00051
+CCc1nc2ccccc2n1CC(F)(F)c1ccccc1 lb_00052
+Cc1ccc(C)c(Cn2c(C)nc3ccccc32)c1 lb_00053
+Cc1nc2ccc(C(F)(F)F)cc2n1-c1ccccc1 lb_00054
+CCC(C)Cn1c(C)nc2ccccc21 lb_00055
+CCCCCCCCCCCCn1c(C)nc2ccccc21 lb_00056
+CCCCCCCCCCn1c(C)nc2ccccc21 lb_00057
+CCCn1c(C(F)(F)F)nc2ccccc21 lb_00058
+CCCCCCCCn1c(C)nc2ccccc21 lb_00059
+CCCCCCCCCn1c(C)nc2ccccc21 lb_00060
+FC(F)(F)c1cccc(-c2nc3ccccc3n2CCCc2ccccc2)c1 lb_00061
+FC(F)(F)c1cc(CN2CCN(Cc3nc4ccccc4n3Cc3ccccc3)CC2)cc(C(F)(F)F)c1 lb_00062
+C=CCn1c(-c2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00063
+Cc1cccc(Cn2c(C(F)(F)F)nc3ccccc32)c1 lb_00064
+Nc1nc2ccccc2n1Cc1cccc(C(F)(F)F)c1 lb_00065
+FC(F)(F)c1cccc(Cn2c(Cl)nc3ccccc32)c1 lb_00066
+C=CCn1c(-c2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00067
+N#CCn1c(-c2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00068
+FC(F)(F)c1ccc(-c2ccc(-c3nc4ccccc4n3Cc3ccccc3)cc2)cc1 lb_00069
+Cn1c(-c2cc(N)cc(C(F)(F)F)c2)nc2ccccc21 lb_00070
+Cc1ccccc1Cn1c(C(F)(F)F)nc2ccccc21 lb_00071
+Cn1c(-c2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00072
+Cc1ccc(Cn2c(C(F)(F)F)nc3ccccc32)cc1 lb_00073
+Cn1c(-c2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00074
+Br.CCCCCCCCCCCCn1c(C)nc2ccccc21 lb_00075
+CCCCCCCCCn1c(C)nc2ccccc21.Cl lb_00076
+Fc1cc(F)cc(Cn2c(-c3ccc(-c4ccc(C(F)(F)F)cc4)cc3)nc3ccccc32)c1 lb_00077
+Cc1ccc(C)c(Cn2c(C(F)(F)F)nc3ccccc32)c1 lb_00078
+Cc1nc2ccccc2n1Cc1ccc(-c2ccccc2)cc1F lb_00079
+CCn1c(NCc2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00080
+CCCn1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00081
+Cc1nc2ccccc2n1Cc1ccc(F)cc1CN lb_00082
+Cc1nc2ccccc2n1Cc1cc(F)ccc1CN lb_00083
+FC(F)(F)c1cc(Cn2c3ccccc3c3nc4ccccc4nc32)cc(C(F)(F)F)c1 lb_00084
+CC(C)(C)c1ccc(-c2nc3ccccc3n2CCF)cc1 lb_00085
+Cc1nc2ccccc2n1Cc1cccc2ccccc12 lb_00086
+Cc1nc2ccccc2n1C/C=C/c1ccccc1 lb_00087
+CCCn1c(Nc2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00088
+CCNc1nc2ccccc2n1Cc1cccc(C(F)(F)F)c1 lb_00089
+CCCCn1c(C(F)(F)F)nc2ccccc21 lb_00090
+Cc1nc2ccccc2n1Cc1ccc(CN)cc1F lb_00091
+Cc1nc2ccccc2n1CC(N)c1cccc(F)c1 lb_00092
+Cc1nc2ccccc2n1Cc1cc(CN)ccc1F lb_00093
+Cc1nc2ccccc2n1CC(N)c1ccc(F)c(F)c1 lb_00094
+Cc1nc2ccccc2n1C(F)(F)C(F)F lb_00095
+FC(F)(F)c1nc2ccccc2n1CC#CCn1c(C(F)(F)F)nc2ccccc21 lb_00096
+Fc1ccc(Cn2c(CN3CCN(Cc4cc(C(F)(F)F)cc(C(F)(F)F)c4)CC3)nc3ccccc32)cc1 lb_00097
+CCn1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00098
+FC(F)(F)c1ccc(Cn2c(CBr)nc3ccccc32)cc1 lb_00099
+Cn1c(-c2ccc(C(F)(F)F)cc2C(F)(F)F)nc2ccccc21 lb_00100
+Cc1nc2ccccc2n1CC(N)c1ccccc1F lb_00101
+Cc1nc2ccccc2n1CC(N)c1ccc(F)cc1 lb_00102
+Cc1nc2ccccc2n1CC(N)c1c(F)cccc1F lb_00103
+Nc1cccc(-c2nc3ccccc3n2Cc2ccc(C(F)(F)F)cc2)c1 lb_00104
+CCn1c(C)nc2cc(C(C(F)(F)F)(C(F)(F)F)C(F)(F)F)ccc21 lb_00105
+Cc1nc2cc(C(F)(F)F)ccc2n1-c1ccccc1 lb_00106
+Cc1nc2ccccc2n1CC(N)c1ccc(F)cc1F lb_00107
+Cc1nc2ccccc2n1CC(N)c1cc(F)ccc1F lb_00108
+Cc1nc2ccccc2n1Cc1cc(C#N)ccc1F lb_00109
+CCN(CC)CCCn1c(C)nc2cc(C(F)(F)F)ccc21 lb_00110
+CCCn1c(-c2ccccc2C)nc2cc(C(F)(F)F)ccc21 lb_00111
+Fc1ccc(Cn2c(-c3ccc(-c4ccc(C(F)(F)F)cc4)cc3)nc3ccccc32)cc1 lb_00112
+FC(F)(F)c1nc2ccccc2n1Cc1ccccc1 lb_00113
+FC(F)(F)c1cc(-n2cnc3ccccc32)cc(C(F)(F)F)c1 lb_00114
+Cc1ccc(C=Cc2nc3ccccc3n2Cc2cccc(C(F)(F)F)c2)cc1 lb_00115
+Cc1ccc(/C=C/c2nc3ccccc3n2Cc2cccc(C(F)(F)F)c2)cc1 lb_00116
+Nc1cccc(-c2nc3ccccc3n2CC(F)(F)F)c1 lb_00117
+Cn1c(-c2cc(C(F)(F)F)ccc2N)nc2ccccc21 lb_00118
+CCCCn1c(C)nc2cc(C(F)(F)F)cc(N)c21 lb_00119
+CCCCn1c(Nc2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00120
+CCn1c(C(C)(C)C)nc2ccccc21 lb_00121
+Nc1ccc(-c2nc3ccccc3n2CC(F)(F)F)cc1 lb_00122
+Cn1c(Cn2c(C(F)(F)F)nc3ccccc32)nc2ccccc21 lb_00123
+CCCCCCn1c(C(F)(F)F)nc2ccccc21 lb_00124
+Nc1nc2ccccc2n1CCCc1cccc(C(F)(F)F)c1 lb_00125
+FC(F)(F)c1cc(CNCc2nc3ccccc3n2-c2ccccc2)cc(C(F)(F)F)c1 lb_00126
+FC(F)(F)c1ccc(Cn2c(CBr)nc3ccccc32)c(C(F)(F)F)c1 lb_00127
+CN(C)CCn1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00128
+Cc1nc2ccccc2n1CCNCc1cccc(F)c1 lb_00129
+CCCCN(CCCC)CCCn1c(C)nc2cc(C(F)(F)F)ccc21 lb_00130
+Fc1ccc(Cn2c(CNc3cc(C(F)(F)F)cc(C(F)(F)F)c3)nc3ccccc32)c(F)c1 lb_00131
+CCn1c(C(C)NCc2cc(F)cc(C(F)(F)F)c2)nc2ccccc21 lb_00132
+FC(F)(F)c1nc2ccccc2n1CCc1ccccc1 lb_00133
+C=CCn1c(C(F)(F)F)nc2ccccc21 lb_00134
+Cc1cc(C(F)(F)F)ccc1-c1nc2ccccc2n1-c1c(C)cccc1C lb_00135
+Cc1ccc(NCCn2c(C(F)(F)F)nc3ccccc32)cc1 lb_00136
+Cc1nc2ccccc2n1CCNCc1ccc(F)cc1 lb_00137
+Cc1nc2ccccc2n1CCNCc1ccccc1F lb_00138
+CCn1c(-c2ccccc2C)nc2cc(C(F)(F)F)ccc21 lb_00139
+CC(C)(C)c1nc2cc(C(F)(F)F)ccc2n1Cc1ccccc1 lb_00140
+CCCCCn1c(Nc2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00141
+Cc1nc2cc(C(F)(F)F)ccc2n1C lb_00142
+CC(C)(C)c1ccc(Cn2c(-c3ccc(C(C)(C)C)cc3)nc3ccccc32)cc1 lb_00143
+FC(F)(F)c1nc2ccccc2n1Cc1ccc2ccccc2c1 lb_00144
+I.Nc1nc2ccccc2n1CCCc1cccc(C(F)(F)F)c1 lb_00145
+FC(F)(F)c1cccc(CNc2nc3ccccc3n2Cc2ccccc2)c1 lb_00146
+CC1=CN=C(n2c(C)nc3ccccc32)N(c2ccc(C(F)(F)F)cc2)C1 lb_00147
+Cc1cc(-c2nc3ccccc3n2C2CCC2)cc(C(F)(F)F)c1 lb_00148
+CC(C)(CNc1nc2ccccc2[nH]1)c1cc(F)cc(C(F)(F)F)c1 lb_00149
+Cc1nc2ccccc2n1Cc1cc(C(N)=S)ccc1F lb_00150
+Cc1nc2ccccc2n1Cc1ccc(F)cc1C(=N)N lb_00151
+Cl.Fc1ccc(Cn2c(CNc3cc(C(F)(F)F)cc(C(F)(F)F)c3)nc3ccccc32)c(F)c1 lb_00152
+CC(C)=CCCC(C)CCn1c(-c2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00153
+CC(C)(CC(=O)O)Cc1nc2ccccc2n1Cc1cccc(C(F)(F)F)c1 lb_00154
+CC(C)n1c(-c2ccc(C(F)(F)F)cc2C(F)(F)F)nc2ccccc21 lb_00155
+CCc1nc2ccccc2n1CCCCNc1cccc(C(F)(F)F)c1 lb_00156
+CC.OB(O)Cc1nc2ccccc2n1Cc1ccc(C(F)(F)F)cc1C(F)(F)F lb_00157
+CCCCCCn1c(Nc2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00158
+CC(C)Cn1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00159
+Cn1c(C(F)(F)F)nc2ccccc21 lb_00160
+Cc1nc2ccccc2n1C(F)F lb_00161
+FC(F)(F)c1cc(C2SCc3nc4ccccc4n32)cc(C(F)(F)F)c1 lb_00162
+CCN(CC)CCn1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00163
+CN(C)CCCn1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00164
+Cc1cc(C)cc(NC(=O)Cn2c(C(F)(F)F)nc3ccccc32)c1 lb_00165
+FC(F)(F)c1cccc(-c2nc3ccccc3n2-c2ccccc2)c1 lb_00166
+FC(F)(F)c1ccccc1Cn1c(-c2ccccc2C(F)(F)F)nc2ccccc21 lb_00167
+Cc1cccc(C)c1-n1c(-c2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00168
+CC(C)(C)c1ccc(-c2nc3ccccc3n2Cc2ccccc2)cc1 lb_00169
+Fc1cccc(Cn2c(C(F)(F)F)nc3ccccc32)c1 lb_00170
+CCCn1c(-c2ccc(F)c(F)c2)nc2ccccc21 lb_00171
+CCCn1c(-c2cccc(Br)c2)nc2ccccc21 lb_00172
+CC(C)=CCC/C(C)=C/Cn1c(C)nc2ccccc21 lb_00173
+Cn1c(Nc2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00174
+CCCn1c(-c2ccccc2)nc2ccccc21 lb_00175
+CN(C)CCn1c(NCc2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00176
+Nc1nonc1-c1nc2ccccc2n1Cc1cccc(C(F)(F)F)c1 lb_00177
+FC(F)(F)c1ccc(Cn2c(CN3CCCC3)nc3ccccc32)cc1 lb_00178
+Cc1ccccc1N1CCN(c2nc3ccccc3n2CC(F)(F)F)CC1 lb_00179
+CC(C)(C)c1ccc(Cn2c(-c3ccc(F)cc3)nc3ccccc32)cc1 lb_00180
+CC(C)(C)c1ccc(Cn2c(-c3ccccc3F)nc3ccccc32)cc1 lb_00181
+CCCn1c(-c2cccc(C)c2)nc2cc(C(F)(F)F)ccc21 lb_00182
+CCCn1c(-c2ccccc2F)nc2ccccc21 lb_00183
+CCCn1c(-c2cccc(C)c2)nc2ccccc21 lb_00184
+Cc1ccc(Cn2c(C(C)(C)C)nc3ccccc32)cc1 lb_00185
+Fc1ccc(Cn2c(C(F)(F)F)nc3ccccc32)cc1 lb_00186
+CCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00187
+Fc1ccccc1Cn1c(C(F)(F)F)nc2ccccc21 lb_00188
+CCn1c(C(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00189
+FC(F)(F)c1nc2ccccc2n1Cc1ccc(Cl)cc1 lb_00190
+FC(F)(F)c1ccc(-c2nc3ccccc3n2-c2ccccc2)cc1 lb_00191
+CCCn1c(Cn2ccnc2-c2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00192
+CN(Cc1cc(F)cc(C(F)(F)F)c1)Cc1nc2ccccc2n1C lb_00193
+Cn1c(CN2CCC(c3ccc(C(F)(F)F)cc3)CC2)nc2ccccc21 lb_00194
+CC1=CN(c2ccc(C(F)(F)F)cc2)C(n2c(C)nc3ccccc32)N=C1 lb_00195
+OB(O)Cc1nc2ccccc2n1Cc1ccc(C(F)(F)F)cc1C(F)(F)F lb_00196
+Cc1nc2ccccc2n1C1N=CC=CN1c1ccc(C(F)(F)F)cc1 lb_00197
+FC(F)(F)c1cccc(CN2CCN(Cc3nc4ccccc4n3Cc3ccccc3)CC2)c1 lb_00198
+Cc1nc2ccccc2n1CC1CCN(Cc2cc(F)cc(F)c2)CC1 lb_00199
+FC(F)(F)c1ccc2c(c1)nc(-c1ccccn1)n2CCc1ccccc1 lb_00200
+Cc1nc2ccccc2n1CCCN(C)Cc1ccccc1 lb_00201
+FC(F)(F)c1ccc2c(c1)nc(-c1ccccc1)n2Cc1ccccc1 lb_00202
+CC(C)c1ccc(Cn2c(C(F)(F)F)nc3ccccc32)cc1 lb_00203
+CC(C)(C)c1nc2ccccc2n1Cc1ccccc1 lb_00204
+CC.OB(O)CCc1nc2ccccc2n1Cc1ccc(C(F)(F)F)cc1C(F)(F)F lb_00205
+Cl.Cl.FC(F)(F)c1ccc(Cn2c(CN3CCCC3)nc3ccccc32)cc1 lb_00206
+Cc1ccccc1-c1nc2cc(C(F)(F)F)ccc2n1CC(C)C lb_00207
+Cc1ccccc1-c1nc2cc(C(F)(F)F)ccc2n1Cc1ccccc1 lb_00208
+Cc1ccc(-c2nc3cc(C(F)(F)F)ccc3n2Cc2ccccc2)cc1 lb_00209
+CN(CCN(C)c1nc2ccccc2n1Cc1ccc(F)cc1)C(=O)NCc1cc(C(F)(F)F)cc(C(F)(F)F)c1 lb_00210
+CC(C)(C)c1ccc(Cn2c(N)nc3ccccc32)cc1 lb_00211
+Nc1nc2ccccc2n1Cc1ccccc1C(F)(F)F lb_00212
+Nc1ccc(Cn2c(C(F)(F)F)nc3ccccc32)cc1 lb_00213
+FC(F)(F)Cn1c(C#Cc2ccccc2)nc2ccccc21 lb_00214
+FC(F)(F)c1nc2ccccc2n1Cc1cccc2ccccc12 lb_00215
+CC(C)(C)c1nc2ccccc2n1Cc1ccc(F)cc1 lb_00216
+CC(C)(C)c1nc2ccccc2n1Cc1ccccc1F lb_00217
+FC(F)(F)c1nc2ccccc2n1CCCc1ccccc1 lb_00218
+FC(F)(F)c1nc2ccccc2n1Cc1ccccc1Cl lb_00219
+CC(C)Cc1ccc(C(C)c2nc3ccccc3n2Cc2ccc(C(F)(F)F)cc2)cc1 lb_00220
+Cc1nc2ccccc2n1C1N=CC(F)=CN1c1ccc(C(F)(F)F)cc1 lb_00221
+CCN(CC)CCCn1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00222
+Cc1ccccc1-c1nc2cc(C(F)(F)F)ccc2n1CCCN(C)C lb_00223
+CCN(CC)CCn1c(-c2ccccc2C)nc2cc(C(F)(F)F)ccc21 lb_00224
+CC(C)(C)c1cc(NC(=O)Cn2c(-c3ccccc3)nc3ccccc32)cc(C(C)(C)C)c1 lb_00225
+Cc1ccc(NC(=O)Cn2c(C(F)(F)F)nc3ccccc32)cc1C lb_00226
+CCn1c(-c2ccccc2)nc2ccccc21 lb_00227
+Cc1cccc(Cn2c(CC(C)(C)C)nc3ccccc32)c1 lb_00228
+Cc1cccc(Cn2c(C(C)(C)N)nc3ccccc32)c1 lb_00229
+Cc1ccc(C(F)(F)F)cc1Cn1cnc2ccccc21 lb_00230
+CCn1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00231
+CCn1c(-c2cccc(C)c2)nc2cc(C(F)(F)F)ccc21 lb_00232
+CCCn1c(-c2ccc(C)cc2)nc2cc(C(F)(F)F)ccc21 lb_00233
+CCc1nc2cc(C(F)(F)F)ccc2n1Cc1ccccc1 lb_00234
+CCCn1c(-c2cccc(C(F)(F)F)c2)nc2cc3nc(-c4cccc(C(F)(F)F)c4)n(CCC)c3cc21 lb_00235
+CCCCn1c(-c2cccc(Br)c2)nc2ccccc21 lb_00236
+CCCCn1c(-c2ccccc2)nc2ccccc21 lb_00237
+CCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00238
+Cn1c(-c2ccccc2C(F)(F)F)nc2ccccc21 lb_00239
+CCn1c(C)nc2cc(-c3ccccc3)ccc21 lb_00240
+Cn1c(-c2cc(-c3nc4ccccc4n3C)cc(C(C)(C)C)c2)nc2ccccc21 lb_00241
+CCn1c(-c2ccccc2F)nc2ccccc21 lb_00242
+C=CCn1c(C(C)(C)C)nc2ccccc21 lb_00243
+Nc1nc2ccccc2n1-c1ccc(C(F)(F)F)cc1 lb_00244
+CC(F)(F)c1ccc(Cn2c(CN3CCCC3)nc3ccccc32)cc1 lb_00245
+Cc1cccc(-c2nc3cc(C(F)(F)F)ccc3n2Cc2ccccc2)c1 lb_00246
+Cc1nc2ccccc2n1Cc1ccc2c(c1)CCc1ccccc1N2 lb_00247
+Cn1c(/C=C/c2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00248
+Cc1ccccc1Cn1c(CC(C)(C)C)nc2ccccc21 lb_00249
+Cn1c(C=Cc2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00250
+Cn1c(C#Cc2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00251
+CCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00252
+CC(F)(F)c1ccc(-c2nc3ccccc3n2-c2ccccc2)cc1 lb_00253
+Cc1cccc(-c2nc3ccccc3n2CCc2ccccc2)c1 lb_00254
+CCCCn1c(-c2c(F)cccc2F)nc2ccccc21 lb_00255
+FC(F)(F)c1nc2ccccc2n1C/C=C/c1ccccc1 lb_00256
+CCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00257
+CCCn1c(C(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00258
+CCCn1c(-c2ccc(C(F)(F)F)cc2)nc2cc3nc(-c4ccc(C(F)(F)F)cc4)n(CCC)c3cc21 lb_00259
+Cc1nc2ccccc2n1CC1CCN(Cc2ccc(F)c(F)c2)CC1 lb_00260
+CC(C)(C)c1ccc(N2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)cc1 lb_00261
+Cc1nc2ccccc2n1CC1CCN(Cc2cccc(F)c2)CC1 lb_00262
+CCCCN(CCCC)CCCn1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00263
+Cc1nc2cc(C(F)(F)F)ccc2n1C[C@@H]1CCCN2CCCC[C@H]12 lb_00264
+CC(C)(N)c1nc2ccccc2n1Cc1cccc(F)c1 lb_00265
+Cn1c(C(F)(F)c2ccccc2)nc2ccccc21 lb_00266
+Nc1nc2ccccc2n1Cc1ccc(F)cc1C(F)(F)F lb_00267
+CN1CCC(n2c(C(N)Cc3cc(C(F)(F)F)cc(C(F)(F)F)c3)nc3ccccc32)CC1 lb_00268
+CC(C)c1nc2ccccc2n1-c1ccc(C(F)(F)F)cc1C(F)(F)F lb_00269
+CCCn1c(Nc2ccccc2C(F)(F)F)nc2ccccc21 lb_00270
+CCCn1c(-c2ccc(F)cc2)nc2cc(C(F)(F)F)ccc21 lb_00271
+CCC(c1ccccc1)c1nc2cc(C(F)(F)F)ccc2n1CC lb_00272
+CC(C)c1nc2cc(C(F)(F)F)ccc2n1Cc1ccccc1 lb_00273
+CCCn1c(-c2ccc(F)c(N)c2)nc2ccccc21 lb_00274
+CCCn1c(-c2cc(N)ccc2F)nc2ccccc21 lb_00275
+CCCn1c(-c2cc(N)c(F)cc2F)nc2ccccc21 lb_00276
+CCCn1c(-c2ccc(N)c(F)c2)nc2ccccc21 lb_00277
+CCC(c1ccccc1)c1nc2ccccc2n1-c1ccc(C(F)(F)F)cc1 lb_00278
+CC(C)n1c(C(F)(F)F)nc2ccccc21 lb_00279
+CN(CCN(C)C(=O)NCc1cc(C(F)(F)F)cc(C(F)(F)F)c1)Cc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00280
+Cc1nc2ccccc2n1Cc1ccc(B2OC(C)(C)C(C)(C)O2)cc1 lb_00281
+Cn1c(CN2CCN(Cc3cccc(C(F)(F)F)c3)CC2)nc2ccccc21 lb_00282
+Cc1nc2ccccc2n1CC1CCN(Cc2ccc(F)cc2)CC1 lb_00283
+Cc1nc2ccccc2n1CC1CCN(Cc2ccccc2F)CC1 lb_00284
+CCCCCn1c(-c2ccccc2)nc2ccccc21 lb_00285
+CC(c1ccccc1)n1c(C(F)(F)F)nc2ccccc21 lb_00286
+CC(C)CCn1c(-c2ccccc2)nc2ccccc21 lb_00287
+CC(C)(C)Cc1nc2ccccc2n1Cc1ccccc1 lb_00288
+C[C@@H](c1ccccc1)n1c(C(F)(F)F)nc2ccccc21 lb_00289
+C[C@H](c1ccccc1)n1c(C(F)(F)F)nc2ccccc21 lb_00290
+COCCn1c(-c2ccccc2)nc2ccccc21 lb_00291
+CCn1c(N)nc2cc(C(F)(F)F)ccc21 lb_00292
+Cn1c(CN2CCC(c3cccc(C(F)(F)F)c3)CC2)nc2ccccc21 lb_00293
+Cc1nc2ccccc2n1CC1CCN(Cc2cc(F)ccc2F)CC1 lb_00294
+CCN(CC)CCCn1c(-c2ccccc2C)nc2cc(C(F)(F)F)ccc21 lb_00295
+O[B-](O)(O)CSc1nc2ccccc2n1Cc1ccc(C(F)(F)F)cc1C(F)(F)F lb_00296
+CCCCCn1c(-c2cccc(C)c2)nc2ccccc21 lb_00297
+Cc1cccc(-c2nc3ccccc3n2CCC(C)C)c1 lb_00298
+FC(F)(F)c1nc2ccccc2n1CCC1CCCCC1 lb_00299
+CC(C)(C)Cc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00300
+CC(C)CCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00301
+CN(C)c1ccc(-c2nc3ccccc3n2CCF)cc1 lb_00302
+CCCCCn1c(-c2c(F)cccc2F)nc2ccccc21 lb_00303
+Cc1ccc2c(c1)nc(C(F)(F)F)n2Cc1ccccc1 lb_00304
+CCc1ccc(-c2ccc(-c3nc4ccccc4n3CCF)cc2)cc1 lb_00305
+CCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00306
+CCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00307
+CC(C)CCn1c(-c2ccccc2F)nc2ccccc21 lb_00308
+CCn1c(-c2ccc(C)cc2)nc2cc(C(F)(F)F)ccc21 lb_00309
+CC(C)Cn1c(C(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00310
+CC(C)(O)c1nc2ccccc2n1Cc1ccccc1F lb_00311
+CC(C)(O)c1nc2ccccc2n1Cc1ccc(F)cc1 lb_00312
+CC(F)(F)c1nc2ccccc2n1CC1CCC(F)(F)CC1 lb_00313
+CC(C)c1cccc(C(C)C)c1-n1c(-c2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00314
+CCC(C)c1ccc(Cn2c(C(F)(F)F)nc3ccccc32)cc1 lb_00315
+N#Cc1cccc(Cn2c(C(F)(F)F)nc3ccccc32)c1 lb_00316
+Cn1c(CN2CCN(Cc3ccc(C(F)(F)F)cc3)CC2)nc2ccccc21 lb_00317
+CCCn1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00318
+CCCc1nc2cc(C(F)(F)F)ccc2n1Cc1ccccc1 lb_00319
+FC(F)(F)c1cccc(Cn2c3ccccc3c3nc4ccccc4nc32)c1 lb_00320
+CCn1c(-c2ccc(C)cc2)nc2ccccc21 lb_00321
+c1ccc(CCn2c(-c3ccccc3)nc3ccccc32)cc1 lb_00322
+Cc1cccc(Cn2c(C(C)(C)N)nc3cc(C(F)(F)F)ccc32)c1 lb_00323
+Cc1ccc(-c2nc3cc(C(F)(F)F)ccc3n2Cc2ccccc2)c(C)c1 lb_00324
+Cc1nc2ccccc2n1CCNCc1cccc(C#N)c1 lb_00325
+CN(C)CCn1c(Cn2nc3ccccc3n2)nc2cc(C(F)(F)F)ccc21 lb_00326
+Cn1c(-c2cccc(C(C)(C)C)c2)nc2ccccc21 lb_00327
+CC(C)(C)Cc1nc2ccccc2n1CCc1ccccc1 lb_00328
+CCCCCCCn1c(-c2ccccc2)nc2ccccc21 lb_00329
+CCCCCCn1c(-c2ccccc2)nc2ccccc21 lb_00330
+CCCCn1c(-c2ccc(C)cc2)nc2ccccc21 lb_00331
+CCCCCCCCCCCCn1c(-c2ccccc2)nc2ccccc21 lb_00332
+CCCCn1c(-c2ccccc2C)nc2ccccc21 lb_00333
+Cn1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00334
+C=CCn1c(CC(C)(C)C)nc2ccccc21 lb_00335
+CCCn1c(-c2ccc(N)cc2)nc2ccccc21 lb_00336
+CC1(CC(F)F)Cn2c(nc3ccccc32)-c2ccc(C(F)(F)F)cc21 lb_00337
+CCCCN(CCCC)CCCn1c(-c2ccccc2C)nc2cc(C(F)(F)F)ccc21 lb_00338
+CC(C)(C)c1ccc(Cn2c(Cc3ccccc3)nc3ccccc32)cc1 lb_00339
+FC(F)(F)c1ccc([C@H]2Cc3nc4ccccc4n3C2)cc1 lb_00340
+CN(C)c1ccc(-c2ccc(-c3nc4ccccc4n3CCF)cc2)cc1 lb_00341
+CC(C)(C)c1nc2ccccc2n1CC1CCC(F)CC1 lb_00342
+CCCCCCCCCCCCCCCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00343
+CCCCCCCCCCCCCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00344
+CCCCCCCCCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00345
+CCCCCCCCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00346
+CCCCCCCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00347
+CCCCCCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00348
+CCCCCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00349
+CCCCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00350
+CCCCCCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00351
+CCCCCCCCCCCCCCCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00352
+CCCCCCCCCCCCCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00353
+CCCCCCCCCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00354
+CCCCCCCCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00355
+CCCCCCCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00356
+CCCCCCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00357
+CCCCCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00358
+CCCCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00359
+CCCCCCn1c(-c2ccccc2F)nc2ccccc21 lb_00360
+N#Cc1ccccc1Cn1c(C(F)(F)F)nc2ccccc21 lb_00361
+FC(F)(F)c1ccc2c(c1)nc(Cc1ccccc1)n2Cc1ccccc1 lb_00362
+CC(C)Cn1c(-c2cccc(Br)c2)nc2ccccc21 lb_00363
+CC(C)(C)c1ccc(CCn2c(N)nc3ccccc32)cc1F lb_00364
+CCCCn1c(Nc2ccccc2C(F)(F)F)nc2ccccc21 lb_00365
+CCCCn1c(-c2ccc(F)cc2)nc2cc(C(F)(F)F)ccc21 lb_00366
+N#Cc1ccc(F)c(Cn2c(C(F)(F)F)nc3ccccc32)c1 lb_00367
+CCCn1c(C(CC)c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00368
+CCCn1c(-c2ccc(C)cc2C)nc2cc(C(F)(F)F)ccc21 lb_00369
+CC(C)Cn1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00370
+Cc1cccc(-c2nc3cc(C(F)(F)F)ccc3n2CC(C)C)c1 lb_00371
+CNCc1nc2cc(C(F)(F)F)ccc2n1Cc1ccccc1 lb_00372
+Cc1nc2ccccc2n1CCCCN1CCN(C(c2ccccc2)c2ccccc2)CC1 lb_00373
+FC(F)(F)n1c(-c2ccccc2)nc2ccccc21 lb_00374
+Cc1ccccc1-n1c(C)nc2ccccc21 lb_00375
+COCCCn1c(-c2cccc(C)c2)nc2cc(C(F)(F)F)ccc21 lb_00376
+Cc1cccc(-c2nc3cc(C(F)(F)F)ccc3n2CCCN(C)C)c1 lb_00377
+CCN(CC)CCn1c(-c2cccc(C)c2)nc2cc(C(F)(F)F)ccc21 lb_00378
+Cn1c([C@H]2CCN(Cc3ccc(C(F)(F)F)cc3)C2)nc2ccccc21 lb_00379
+Cn1c(C2CCN(Cc3ccc(C(F)(F)F)cc3)C2)nc2ccccc21 lb_00380
+Cc1cccc(NC(=O)Cn2c(C(F)(F)F)nc3ccccc32)c1C lb_00381
+CC(C)Cn1c(-c2ccccc2)nc2ccccc21 lb_00382
+Cc1cc2nc(C)n(Cc3ccccc3)c2cc1C lb_00383
+COCn1c(-c2ccccc2)nc2ccccc21 lb_00384
+FC(F)(F)c1cc(-c2nc3ccccc3[nH]2)cc(C(F)(F)F)c1 lb_00385
+Cc1cccc(CN2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)c1 lb_00386
+CC(C)(C)c1ccc(-c2nc3ccccc3n2C(F)F)cc1 lb_00387
+Cc1cccc(-c2nc3ccccc3n2Cc2ccccc2)c1 lb_00388
+Cc1cccc(Cn2c(N)nc3ccccc32)c1 lb_00389
+Cc1cccc(Cn2c(-c3cccc(C)c3)nc3ccccc32)c1 lb_00390
+Cc1cc2nc(C)n(Cc3ccccc3F)c2cc1C lb_00391
+FC(c1nc2ccccc2n1Cc1ccccc1)C(F)(F)F lb_00392
+Cc1cc(C)c(Cn2c(-c3ccccc3)nc3ccccc32)c(C)c1 lb_00393
+Fc1ccc(-c2nc3ccccc3n2CCc2ccccc2)cc1 lb_00394
+Fc1ccccc1-c1nc2ccccc2n1CCc1ccccc1 lb_00395
+CC(C)Cn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00396
+CC(C)Cn1c(-c2ccccc2F)nc2ccccc21 lb_00397
+CCOCCn1c(-c2ccccc2)nc2ccccc21 lb_00398
+CCN(CC)CCn1c(C(C)(C)C)nc2ccccc21 lb_00399
+Cc1nc2cc(N)ccc2n1Cc1ccccc1.Cl lb_00400
+FC(F)(F)c1ccc2nc(-c3ccccc3)n(-c3ccccc3)c2c1 lb_00401
+CC(C)CCn1c(CC(C)(C)C)nc2ccccc21 lb_00402
+CCn1c(-c2ccccc2-c2ccc(F)cc2F)nc2ccccc21 lb_00403
+Cc1cccc(-c2nc3ccccc3n2Cc2ccccc2F)c1 lb_00404
+Cc1cccc(-c2nc3ccccc3n2Cc2ccc(F)cc2)c1 lb_00405
+Cc1cc(C)c(Cn2c(-c3ccc(F)cc3)nc3ccccc32)c(C)c1 lb_00406
+Cc1cc(C)c(Cn2c(-c3ccccc3F)nc3ccccc32)c(C)c1 lb_00407
+Cc1cc(C)c(C)c(Cn2c(-c3ccc(F)cc3)nc3ccccc32)c1C lb_00408
+Cc1cc(C)c(C)c(Cn2c(-c3ccccc3F)nc3ccccc32)c1C lb_00409
+Cc1nc2ccccc2n1C(CN)c1cccc(F)c1 lb_00410
+COCc1nc2ccccc2n1Cc1ccc(C(C)(C)C)cc1 lb_00411
+CN(CCCN(C)c1nc2ccccc2n1Cc1ccc(F)cc1)C(=O)NCc1cc(C(F)(F)F)cc(C(F)(F)F)c1 lb_00412
+Cn1c(CN2CCN(c3ccc(C(F)(F)F)cc3)CC2)nc2ccccc21 lb_00413
+FC(F)(F)c1ccc2c(c1)nc(C1CC1)n2CCc1ccccc1 lb_00414
+CN(C)c1cccc(-c2ccc(-c3nc4ccccc4n3CCF)cc2)c1 lb_00415
+CCCCCn1c(Nc2ccccc2C(F)(F)F)nc2ccccc21 lb_00416
+CCC(c1ccccc1)c1nc2cc(C(F)(F)F)ccc2n1CC(C)C lb_00417
+CCC(C)c1nc2cc(C(F)(F)F)ccc2n1Cc1ccccc1 lb_00418
+CCC(c1ccccc1)c1nc2cc(C(F)(F)F)ccc2n1Cc1ccccc1 lb_00419
+Cc1nc2ccccc2n1CCCCN1CC=C(c2ccc(F)cc2)CC1 lb_00420
+Cn1c(CCN2CCN(c3cccc(C(F)(F)F)c3)CC2)nc2ccccc21 lb_00421
+Cc1ccccc1CN1CCC(Cn2c(C(F)(F)F)nc3ccccc32)CC1 lb_00422
+Cc1ccc(CN2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)cc1 lb_00423
+CCCn1c(CC)nc2ccccc21 lb_00424
+Cn1c(C(F)(F)C(F)(F)F)nc2ccccc21 lb_00425
+Cn1c(CC(C)(C)C)nc2ccccc21 lb_00426
+FC(F)(F)c1nc2ccccc2n1-c1ccccc1 lb_00427
+Cc1ccc(C)c(CN2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)c1 lb_00428
+Cc1ccc(Cn2c(N)nc3ccccc32)cc1 lb_00429
+Cc1ccc(Cn2c(-c3ccc(C)cc3)nc3ccccc32)cc1 lb_00430
+CCn1c(-c2ccc(N)cc2)nc2ccccc21 lb_00431
+Cc1cccc(Cn2c(-c3ccccc3)nc3ccccc32)c1 lb_00432
+CCCn1c(-c2ccc(N(C)C)cc2)nc2ccccc21 lb_00433
+C=CCn1c(-c2cccc(C)c2)nc2ccccc21 lb_00434
+FC(F)(F)c1cccc(Cn2cnc3ccccc32)c1 lb_00435
+CCc1nc2ccccc2n1Cc1cccc(C)c1 lb_00436
+Cc1ccccc1-c1nc2cc(C(F)(F)F)ccc2n1C lb_00437
+Cc1cc(C)c(C)c(Cn2c(CO)nc3ccccc32)c1C lb_00438
+CCCCn1c(-c2ccc(Br)cc2)nc2ccccc21 lb_00439
+CCCCn1c(-c2ccc(N)cc2)nc2ccccc21 lb_00440
+FC(F)(F)c1cc(-c2cnc(-c3cc(C(F)(F)F)cc(C(F)(F)F)c3)n2Cc2ccccc2)cc(C(F)(F)F)c1 lb_00441
+CC(C)(C)c1nc2ccccc2n1CC1CCC(F)(F)CC1 lb_00442
+Cc1cccc(Cn2c(-c3ccc(F)cc3)nc3ccccc32)c1 lb_00443
+Cc1cccc(Cn2c(-c3ccccc3F)nc3ccccc32)c1 lb_00444
+CCn1c(-c2ccc(C)cc2C)nc2cc(C(F)(F)F)ccc21 lb_00445
+Cc1ccc(-c2nc3cc(C(F)(F)F)ccc3n2CC(C)C)cc1 lb_00446
+Cc1cccc(Cn2c(-c3cccc(Br)c3)nc3ccccc32)c1 lb_00447
+Cc1ccc2nc(-c3ccc(C(F)(F)F)cc3)n(Cc3cccc(C(F)(F)F)c3)c2c1 lb_00448
+CCN(CC)CCCn1c(-c2cccc(C)c2F)nc2ccccc21 lb_00449
+CCN(CC)CCCn1c(-c2cccc(F)c2)nc2ccccc21 lb_00450
+CCCCCCn1c(Nc2ccccc2C(F)(F)F)nc2ccccc21 lb_00451
+CCCCn1c(-c2ccc(F)c(F)c2)nc2cc(C(F)(F)F)ccc21 lb_00452
+Cc1ccc(-c2nc3cc(C(F)(F)F)ccc3n2CCCN(C)C)cc1 lb_00453
+CCN(CC)CCn1c(-c2ccc(C)cc2)nc2cc(C(F)(F)F)ccc21 lb_00454
+CCn1c(Cc2cccc3ccccc23)nc2cc(C(F)(F)F)ccc21 lb_00455
+CCN(CC)CCCn1c(-c2cccc(C)c2)nc2cc(C(F)(F)F)ccc21 lb_00456
+CC(C)(C)c1cc(NC(=O)Cn2c(Cc3ccccc3)nc3ccccc32)cc(C(C)(C)C)c1 lb_00457
+NCc1ccc(-c2nc3ccccc3n2CCCN2CCCCC2)cc1C(F)(F)F lb_00458
+NCc1ccc(-c2nc3ccccc3n2CCCN2CCCCC2)c(C(F)(F)F)c1 lb_00459
+CCN(CC)CCn1c(Cn2nnc3ccccc32)nc2cc(C(F)(F)F)ccc21 lb_00460
+Cn1c(-c2cc(-c3nc4ccccc4n3C)cc(-c3nc4ccccc4n3C)c2)nc2ccccc21 lb_00461
+c1ccc(Cn2c(-c3ccccc3)nc3ccccc32)cc1 lb_00462
+Cc1nc2ccccc2n1C(C)c1ccccc1 lb_00463
+FC(F)(F)c1ccc(-n2cnc3ccccc32)cc1 lb_00464
+CN(CCCN(C)C(=O)NCc1cc(C(F)(F)F)cc(C(F)(F)F)c1)Cc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00465
+Fc1cccc(F)c1Cn1c(-c2c(F)cccc2F)nc2ccccc21 lb_00466
+C=C(C)Cn1c(-c2ccccc2)nc2ccccc21 lb_00467
+Fc1ccc(Cn2c(-c3ccc(F)cc3)nc3ccccc32)cc1 lb_00468
+Cc1ccccc1Cn1c(-c2ccccc2C)nc2ccccc21 lb_00469
+CCc1nc2ccccc2n1Cc1ccccc1C lb_00470
+CCc1nc2ccccc2n1Cc1ccc(C)cc1 lb_00471
+CCc1nc2ccccc2n1Cc1c(F)c(F)c(F)c(F)c1F lb_00472
+Cc1ccc(Cn2c(-c3ccccc3)nc3ccccc32)cc1 lb_00473
+FC(F)(F)c1ccc(Cn2cnc3ccccc32)cc1 lb_00474
+Cc1ccccc1Cn1c(N)nc2ccccc21.Cl lb_00475
+Cc1nc2ccccc2n1-c1ccc(CN)cc1.Cl lb_00476
+CCc1cccc(C(C)(C)c2nc3ccccc3n2C)c1 lb_00477
+Cc1ccccc1-c1nc2ccccc2n1Cc1c(F)cccc1F lb_00478
+Cc1cccc(Cn2c(Cc3ccccc3)nc3ccccc32)c1 lb_00479
+Fc1cccc(Cn2c(-c3cccc(F)c3)nc3ccccc32)c1 lb_00480
+CCc1nc2ccccc2n1Cc1cccc(F)c1 lb_00481
+Cc1ccc(Cn2c(-c3ccc(F)cc3)nc3ccccc32)cc1 lb_00482
+Cc1ccccc1-c1nc2ccccc2n1Cc1ccccc1F lb_00483
+Cc1ccccc1-c1nc2ccccc2n1Cc1ccc(F)cc1 lb_00484
+Cc1ccc(-c2nc3ccccc3n2Cc2ccccc2F)cc1 lb_00485
+Cc1ccc(-c2nc3ccccc3n2Cc2ccc(F)cc2)cc1 lb_00486
+C=C(C)Cn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00487
+Cc1ccccc1Cn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00488
+C=C(C)Cn1c(-c2ccccc2F)nc2ccccc21 lb_00489
+Cc1ccccc1Cn1c(-c2ccccc2F)nc2ccccc21 lb_00490
+Cc1ccc(Cn2c(-c3ccccc3F)nc3ccccc32)cc1 lb_00491
+Cn1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00492
+CC(C)n1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00493
+Cc1nc2ccccc2n1C(CN)c1ccc(F)cc1 lb_00494
+Cc1nc2ccccc2n1C(CN)c1ccccc1F lb_00495
+CCCn1c(-c2ccc(C#Cc3ccccc3)cc2)nc2ccccc21 lb_00496
+FC(F)(F)c1cc(NCc2nc3ccccc3[nH]2)cc(C(F)(F)F)c1 lb_00497
+CC(C)CCn1c(-c2ccc(N)cc2)nc2ccccc21 lb_00498
+CCN(CC)CCCn1c(-c2ccccc2F)nc2ccccc21 lb_00499
+Cc1ccc(-c2nc3ccccc3n2Cc2ccccc2F)c(C)c1 lb_00500
+Cc1ccc(-c2nc3ccccc3n2Cc2ccc(F)cc2)c(C)c1 lb_00501
+Cc1ccc(C)c(Cn2c(-c3ccc(F)cc3)nc3ccccc32)c1 lb_00502
+Fc1ccc(-c2nc3ccccc3n2CCC2CCCCC2)cc1 lb_00503
+Fc1ccccc1-c1nc2ccccc2n1CCC1CCCCC1 lb_00504
+Cc1ccc(C)c(Cn2c(-c3ccccc3F)nc3ccccc32)c1 lb_00505
+CN(C)CCCn1c(C(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00506
+CCN(CC)CCn1c(C(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00507
+CCC(C)n1c(-c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00508
+FC(F)(F)c1cccc(C2SCc3nc4ccccc4n32)c1 lb_00509
+CC(C)(N)c1nc2cc(C(F)(F)F)ccc2n1Cc1cccc(F)c1 lb_00510
+CCN(CC)CCCn1c(-c2cc(C)ccc2F)nc2ccccc21 lb_00511
+Cc1cccc(-c2nc3ccccc3n2CCCN2CCC(F)CC2)c1 lb_00512
+CCCn1c(Cc2cccc3ccccc23)nc2cc(C(F)(F)F)ccc21 lb_00513
+CC(C)(C)c1ccc(Cn2c(-c3nonc3N)nc3ccccc32)cc1 lb_00514
+Cn1c(CCCN2CCN(c3cccc(C(F)(F)F)c3)CC2)nc2ccccc21 lb_00515
+Cc1nc2ccccc2n1C1N=CC=CN1c1ccc(C(F)(F)F)c(F)c1 lb_00516
+CCc1nc2ccccc2n1C1=C(F)C=NCN1c1ccc(C(F)(F)F)cc1 lb_00517
+CCCCN(CCCC)CCCn1c(-c2cccc(C)c2)nc2cc(C(F)(F)F)ccc21 lb_00518
+Cn1c(NCCN2CCN(c3cccc(C(F)(F)F)c3)CC2)nc2ccccc21 lb_00519
+FC(F)(F)c1cc(Cc2nc3ccccc3n2C(CCc2ccccc2)c2nc3ccccc3[nH]2)cc(C(F)(F)F)c1 lb_00520
+CC(=O)Nc1cccc(C2CCN(CCCn3c(-c4cccc(C(F)(F)F)c4)nc4ccccc43)CC2)c1 lb_00521
+CCc1nc2ccccc2n1Cc1ccccc1 lb_00522
+Fc1ccc(Cn2c(F)nc3ccccc32)cc1 lb_00523
+CCn1c(Cc2ccccc2)nc2ccccc21 lb_00524
+Cc1nc2ccccc2n1/C=C\c1ccccc1 lb_00525
+Cn1c(Cl)nc2cc(C(F)(F)F)ccc21 lb_00526
+Cc1nc2ccccc2n1C1CCCCC1 lb_00527
+CCc1nc2ccccc2n1CC(C)C lb_00528
+CCCCn1c(CC)nc2ccccc21 lb_00529
+Fc1cccc(F)c1Cn1c(-c2ccccc2)nc2ccccc21 lb_00530
+CCn1c(-c2ccc(N(C)C)cc2)nc2ccccc21 lb_00531
+C=CCn1c(-c2ccc(C)cc2)nc2ccccc21 lb_00532
+CCc1nc2ccccc2n1Cc1ccccc1F lb_00533
+CCc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00534
+Fc1ccccc1Cn1c(-c2ccccc2)nc2ccccc21 lb_00535
+Fc1cccc(F)c1-c1nc2ccccc2n1Cc1ccccc1 lb_00536
+Fc1ccccc1Cn1c(-c2ccccc2F)nc2ccccc21 lb_00537
+Fc1ccc(-c2nc3ccccc3n2Cc2ccccc2)cc1 lb_00538
+CCn1c(-c2ccc(C(C)C)cc2)nc2ccccc21 lb_00539
+Cn1c(CC(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00540
+Cc1ccc(Cn2c(C(C)C)nc3ccccc32)cc1 lb_00541
+CC(C)=CCn1c(-c2ccccc2)nc2ccccc21 lb_00542
+Fc1ccc(Cn2c(-c3ccccc3)nc3ccccc32)cc1 lb_00543
+Fc1ccccc1-c1nc2ccccc2n1Cc1ccccc1 lb_00544
+Cc1ccc(Cn2c(CO)nc3ccccc32)cc1 lb_00545
+Cn1c(Nc2ccccc2C(F)(F)F)nc2ccccc21 lb_00546
+CSc1nc2ccccc2n1Cc1ccc(C)cc1 lb_00547
+Cc1ccccc1Cn1c(CO)nc2ccccc21 lb_00548
+Fc1ccc(Cn2c(-c3ccc(F)cc3F)nc3ccccc32)c(F)c1 lb_00549
+CC(C)(C)n1c(Cc2cccc(F)c2)nc2ccccc21 lb_00550
+CCC1CCC(n2c(C(F)(F)F)nc3ccccc32)CC1 lb_00551
+Cc1ccccc1Cc1nc2ccccc2n1Cc1ccccc1F lb_00552
+Fc1ccc(-c2nc3ccccc3n2CCCc2ccccc2)cc1 lb_00553
+Fc1ccccc1-c1nc2ccccc2n1CCCc1ccccc1 lb_00554
+CCC(C)Cn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00555
+CCC(C)Cn1c(-c2ccccc2F)nc2ccccc21 lb_00556
+N#CCn1c(-c2ccc(F)c(F)c2)nc2ccccc21 lb_00557
+Cc1ccc(C)c(Cn2c(CO)nc3ccccc32)c1 lb_00558
+CSc1nc2ccccc2n1Cc1cccc(F)c1 lb_00559
+CCCCCc1nc2ccc(C(F)(F)F)cc2n1CC lb_00560
+Cn1c(NCc2ccc(F)c(C(F)(F)F)c2)nc2ccccc21 lb_00561
+CCN(CC)CCCn1c(C(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00562
+CCN(CC)CCn1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00563
+CCn1c(/C(C#N)=C/c2ccccc2C(F)(F)F)nc2ccccc21 lb_00564
+Cc1cccc(Cn2c([C@H](C)N)nc3cc(C(F)(F)F)ccc32)c1 lb_00565
+N#Cc1cc(Cn2c(C(F)(F)F)nc3ccccc32)ccc1-c1ccccc1 lb_00566
+CN(C)CCCn1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00567
+FC(F)(F)c1cccc(CN2CCCn3c(nc4ccccc43)C2)c1 lb_00568
+Cn1c(-c2cccc(N3CCN(CC(F)(F)F)CC3)c2)nc2ccccc21 lb_00569
+N#Cc1ccc(Cn2c(C(F)(F)F)nc3ccccc32)cc1-c1ccccc1 lb_00570
+Cc1cccc(-c2nc3ccccc3n2CCCN2CCC(F)(F)CC2)c1 lb_00571
+CCn1c(C(C#N)=Cc2ccccc2C(F)(F)F)nc2ccccc21 lb_00572
+Cn1c(C(C#N)=Cc2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00573
+Cn1c(/C(C#N)=C/c2cccc(C(F)(F)F)c2)nc2ccccc21 lb_00574
+CC(c1ccccc1)N1CCC(Cn2c(C(F)(F)F)nc3ccccc32)CC1 lb_00575
+CCN(CC)CCCn1c(-c2ccc(C)cc2)nc2cc(C(F)(F)F)ccc21 lb_00576
+CNc1nc2ccccc2n2c(-c3cccc(C(F)(F)F)c3)cnc12 lb_00577
+CCc1cccc(CC)c1N(COC)C(=O)Cn1c(C)nc2ccccc21 lb_00578
+CCCCn1c(-c2cc(-c3ccc(F)cc3)nc(N)n2)nc2ccccc21 lb_00579
+C[C@@H]1C[C@H](n2c(Cc3ccc(C(F)(F)F)cc3)nc3ccccc32)CC(C)(C)C1 lb_00580
+CC1CC(n2c(Cc3ccc(C(F)(F)F)cc3)nc3ccccc32)CC(C)(C)C1 lb_00581
+CCN(CC)CCCn1c(-c2ccc([C@@H](NC)C(F)(F)F)cc2)nc2ccccc21 lb_00582
+CCN(CC)CCCn1c(-c2ccc(C(NC)C(F)(F)F)cc2)nc2ccccc21 lb_00583
+C=Cc1ccc2c(c1)nc(C)n2Cc1ccccc1CC(C)(F)F.CCc1ccc(C)cc1 lb_00584
+CCN(CC)CCCn1c(Cn2nnc3ccccc32)nc2cc(C(F)(F)F)ccc21 lb_00585
+Cn1c(CN2CCC(CCCc3cc(F)cc(C(F)(F)F)c3)CC2)nc2ccccc21 lb_00586
+Cc1ccc(Cn2c(Cc3ccccc3)nc3ccccc32)cc1 lb_00587
+Cn1c(/C(C#N)=C/c2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00588
+Cc1cccc(Cn2c([C@H](C)N)nc3ccccc32)c1 lb_00589
+CCc1nc2ccccc2n1CCc1ccccc1 lb_00590
+Cc1cccc(Cn2c(CC(C)C)nc3ccccc32)c1 lb_00591
+CCn1c(CCc2ccccc2)nc2ccccc21 lb_00592
+C=CCn1c(-c2ccccc2)nc2ccccc21 lb_00593
+CC(C)c1nc2ccccc2n1Cc1ccccc1 lb_00594
+CC(C)c1nc2ccccc2n1Cc1ccc(F)cc1 lb_00595
+CC(C)c1nc2ccccc2n1Cc1ccccc1F lb_00596
+C=CCn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00597
+CN(C)c1nc2ccccc2n1Cc1ccc(F)cc1 lb_00598
+CC(C)n1c(-c2ccc(N(C)C)c(C(F)(F)F)c2)nc2ccccc21 lb_00599
+Cc1nc2ccccc2n1CCCCC1CC(c2ccc(F)cc2)=CCN1 lb_00600
+COCn1c(C(F)(F)F)nc2ccc(-c3ccccc3)cc21 lb_00601
+COCn1c(C(F)(F)F)nc2cc(-c3ccccc3)ccc21 lb_00602
+FC(F)c1nc2ccccc2n1Cc1ccccc1 lb_00603
+Cc1nc2cc(C(C)(C)C)c(C(F)(F)F)cc2n1C lb_00604
+CC(c1nc2ccccc2n1C)N1CCN(c2cccc(C(F)(F)F)c2)CC1 lb_00605
+Cn1cnc2ccccc21.Fc1cc(CN2CCCCC2)cc(C(F)(F)F)c1 lb_00606
+CN1CCN(Cc2cc(F)cc(C(F)(F)F)c2)CC1.Cn1cnc2ccccc21 lb_00607
+Cn1c(C(C#N)=Cc2ccc(C(F)(F)F)cc2)nc2ccccc21 lb_00608
+Fc1cccc(F)c1-c1nc2ccccc2n1Cc1c(F)c(F)c(F)c(F)c1F lb_00609
+C=CCn1c(-c2ccccc2F)nc2ccccc21 lb_00610
+FC(F)(F)c1nc2ccccc2n1CC1CCN(Cc2ccccc2)CC1 lb_00611
+Fc1cc(F)cc(CN2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)c1 lb_00612
+CCC(c1ccccc1)c1nc2cc(C(F)(F)F)ccc2n1CCCN(C)C lb_00613
+Cc1ccc(-c2nc3cc(C(F)(F)F)ccc3n2CCCN(C)C)c(C)c1 lb_00614
+CCC(c1ccccc1)c1nc2cc(C(F)(F)F)ccc2n1CCN(CC)CC lb_00615
+CCN(CC)CCn1c(-c2ccc(C)cc2C)nc2cc(C(F)(F)F)ccc21 lb_00616
+CCCCN(CCCC)CCCn1c(C(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00617
+CCCCN(CCCC)CCCn1c(-c2ccc(C)cc2)nc2cc(C(F)(F)F)ccc21 lb_00618
+CCC(C)n1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00619
+CCC(C)n1c(-c2ccccc2C)nc2cc(C(F)(F)F)ccc21 lb_00620
+CCC(c1ccccc1)c1nc2cc(C(F)(F)F)ccc2n1C lb_00621
+Cc1ccccc1-c1nc2cc(C(F)(F)F)ccc2n1C(C)C lb_00622
+CCC(C)c1nc2cc(C(F)(F)F)ccc2n1CC(C)C lb_00623
+CC(C)Cn1c(Cc2cccc3ccccc23)nc2cc(C(F)(F)F)ccc21 lb_00624
+Cc1ccc(-c2nc3cc(C(F)(F)F)ccc3n2CC(C)C)c(C)c1 lb_00625
+FC(F)(F)c1ccc2c(c1)nc(C1CCCCC1)n2Cc1ccccc1 lb_00626
+FC(F)(F)c1nc2ccccc2n1C(c1ccccc1)c1ccccc1 lb_00627
+Cc1nc2ccccc2n1C(c1cccc(F)c1)C(C)N lb_00628
+Cc1nc2ccc(-c3cc(N)nc(N)c3)nc2n1CC(F)(F)F lb_00629
+Fc1ccc(Cn2c(Cl)nc3ccccc32)cc1 lb_00630
+COCc1nc2ccccc2n1Cc1cccc(C)c1 lb_00631
+O=C(C1CC1)N1CCN(Cc2nc3ccccc3n2Cc2cccc(C(F)(F)F)c2)CC1 lb_00632
+Cc1cccc(Cn2c(C(C)O)nc3ccccc32)c1 lb_00633
+CC(C)Cn1c(-c2ccccc2Cl)nc2ccccc21 lb_00634
+FC(F)(F)c1cc(-c2ccccc2)n2c(n1)nc1ccccc12 lb_00635
+CCn1c(-c2ccc(C#Cc3ccccc3)cc2)nc2ccccc21 lb_00636
+CCCCn1c(-c2ccc(C#Cc3ccccc3)cc2)nc2ccccc21 lb_00637
+CSc1nc2ccccc2n1Cc1ccccc1F lb_00638
+C=CCn1c(C(C)C)nc2ccccc21 lb_00639
+Cn1c(-c2cccc(-c3nc4ccccc4n3C)c2)nc2ccccc21 lb_00640
+FC(F)(F)c1cccc(CCN2CCC(Nc3nc4ccccc4n3Cc3ccccc3)CC2)c1 lb_00641
+COCCn1c(-c2ccc(C(C)C)cc2)nc2ccccc21 lb_00642
+CCCCn1c(CCC)nc2ccccc21 lb_00643
+Nc1nc2ccccc2n1Cc1cccc(F)c1 lb_00644
+Cn1c(CCc2ccc(NC(=O)Nc3cccc(C(F)(F)F)c3)cc2)nc2ccccc21 lb_00645
+CC(C)Cc1ccc(C(C)c2nc3ccccc3n2Cc2ccccc2C(F)(F)F)cc1 lb_00646
+Cc1cccc(Cn2c([C@@H](N)C(C)C)nc3cc(C(F)(F)F)ccc32)c1 lb_00647
+CC(C)c1ccc(N2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)cc1 lb_00648
+CCc1nc2ccccc2n1C1N=CC=CN1c1ccc(C(F)(F)F)cc1 lb_00649
+CC(C)(C)c1ccc(CN2CCC(n3c(C(F)(F)F)nc4ccccc43)CC2)cc1.Cl lb_00650
+CCN(CC)CCCn1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00651
+CCC(c1ccccc1)c1nc2cc(C(F)(F)F)ccc2n1CCCN(CC)CC lb_00652
+CCCCCCCCn1c(-c2cc(-c3ccc(F)cc3)nc(N)n2)nc2ccccc21 lb_00653
+CCCCCCn1c(-c2cc(-c3ccc(F)cc3)nc(N)n2)nc2ccccc21 lb_00654
+CCCCCCCn1c(-c2cc(-c3ccc(F)cc3)nc(N)n2)nc2ccccc21 lb_00655
+FC(F)(F)c1ccc2c(c1)nc(N1CCc3ccccc3C1)n2Cc1ccccc1 lb_00656
+NC1=NC(c2cccc(C(F)(F)F)c2)n2c(nc3ccccc32)N1 lb_00657
+CCCn1c(NCc2ccc(C(C)(C)C)cc2)nc2cc(C(F)(F)F)ccc21 lb_00658
+CC(C)c1ccc(-c2nc3ccccc3n2Cc2cccc(F)c2)cc1 lb_00659
+CCCCn1c(-c2cc(-c3ccc(C)cc3)nc(N)n2)nc2ccccc21 lb_00660
+C[C@H](N)c1nc2ccccc2n1Cc1cccc(F)c1 lb_00661
+Cc1ccccc1Cc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00662
+CCc1nc2cc(C(F)(F)F)ccc2n1CCN(CC)CC lb_00663
+CCn1c(C2CCCCC2)nc2cc(C(F)(F)F)ccc21 lb_00664
+CC(C)n1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00665
+CCn1c(C(C)(N)c2ccccc2)nc2cc(F)ccc21 lb_00666
+CCn1c(C(C)(N)c2ccccc2)nc2ccc(F)cc21 lb_00667
+CCc1nc2ccccc2n1Cc1ccc(N)cc1F lb_00668
+Cc1ccc(C)c(Cn2c(C(C)O)nc3ccccc32)c1 lb_00669
+CN(CCCn1c(N)nc2cc(C(F)(F)F)ccc21)CCCn1c(N)nc2cc(C(F)(F)F)ccc21 lb_00670
+Cc1ccc(Cn2c(-c3cccc(N)c3)nc3ccccc32)cc1 lb_00671
+Cc1cc(C)c(C)c(Cn2c(CCCO)nc3ccccc32)c1C lb_00672
+Cc1ccccc1Cn1c(Cc2ccccc2)nc2ccccc21 lb_00673
+CCCc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00674
+CCn1c(/C=C/c2ccc(F)cc2)nc2ccccc21 lb_00675
+CCCc1nc2ccccc2n1Cc1ccccc1F lb_00676
+Fc1ccc(Cc2nc3ccccc3n2Cc2ccc(F)c(F)c2)cc1F lb_00677
+CC(C)(C)Cc1nc2cc(F)ccc2n1CC(F)(F)F lb_00678
+FC(F)(F)c1ccc(-c2ccc(Cn3cnc4ccccc43)cc2)cc1 lb_00679
+CC(C)(C)c1ccc2c(c1)nc(C(F)(F)F)n2-c1ccccc1 lb_00680
+CC(C)c1ccc(Cn2c(-c3ccc(C(C)C)cc3)nc3ccccc32)cc1 lb_00681
+CCn1c(C=Cc2ccc(F)cc2)nc2ccccc21 lb_00682
+Fc1ccc(-c2nc3ccccc3n2Cc2ccccc2F)cc1 lb_00683
+Fc1ccc(Cn2c(-c3ccccc3F)nc3ccccc32)cc1 lb_00684
+Cc1cccc(-c2nc3cc(C(F)(F)F)ccc3n2C)c1 lb_00685
+Cc1nc2ccccc2n1C(c1ccc(F)cc1)C(C)N lb_00686
+Cc1nc2ccccc2n1C(c1ccccc1F)C(C)N lb_00687
+CCCn1c(Nc2ccccc2C)nc2ccccc21 lb_00688
+CN1CCN(c2nc3ccccc3n2CCc2ccccc2)CC1 lb_00689
+COCc1nc2ccccc2n1Cc1ccccc1C lb_00690
+Cc1ccccc1Cn1c(C(C)O)nc2ccccc21 lb_00691
+Cn1cccc1-c1nc2ccccc2n1Cc1ccccc1 lb_00692
+CN(C)c1ccc(Cn2c(-c3ccc(N(C)C)cc3)nc3ccccc32)cc1 lb_00693
+CCn1c(CCc2ccccc2)nc2ccccc21.Cl lb_00694
+CCn1c(/C=C/c2ccccc2)nc2ccccc21 lb_00695
+CCCc1nc2ccccc2n1CCc1ccccc1 lb_00696
+CCc1nc2ccccc2n1CCc1ccccc1.Cl lb_00697
+CCCc1nc2ccccc2n1Cc1ccccc1 lb_00698
+CC(C)c1nc2ccccc2n1CCc1ccccc1 lb_00699
+Cn1c(-c2cccc(F)c2)nc2ccccc21 lb_00700
+CCCn1c(Cc2ccccc2)nc2ccccc21 lb_00701
+Nc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00702
+CCc1nc2ccccc2n1CCC(C)C lb_00703
+Nc1nc2ccccc2n1Cc1ccccc1F lb_00704
+CCn1c(NCc2ccccc2)nc2ccccc21 lb_00705
+CCC(C)Cn1c(C(C)C)nc2ccccc21 lb_00706
+Nc1nc2ccccc2n1Cc1ccccc1 lb_00707
+CC1(N2CCC(n3c(-c4cccc(C(F)(F)F)c4)nc4ccccc43)CC2)CCCCCCC1 lb_00708
+CN1CCN(c2cc(-c3ccc(C(F)(F)F)cc3)c(C#N)c3nc4ccccc4n23)CC1 lb_00709
+FC(F)(F)c1nc2ccccc2n1CC1CCN(c2ccc(C3CCCCC3)cc2)CC1 lb_00710
+CCc1nc2ccccc2n1C1N=CC(F)=CN1c1ccc(C(F)(F)F)cc1 lb_00711
+Cc1nc2cc(C(F)(F)F)ccc2n1C1CCN(Cc2ccc(C(C)(C)C)cc2)CC1.Cl lb_00712
+Fc1cccc(CN2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)c1 lb_00713
+Fc1ccc(F)c(CN2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)c1 lb_00714
+Fc1ccc(CN2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)cc1F lb_00715
+CCN(CC)CCCn1c(-c2ccc(C)cc2C)nc2cc(C(F)(F)F)ccc21 lb_00716
+CCCCN(CCCC)CCCn1c(Cc2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00717
+CCCCN(CCCC)CCCn1c(C(CC)c2ccccc2)nc2cc(C(F)(F)F)ccc21 lb_00718
+CC(c1nc2ccccc2n1C(F)F)N1CCN(c2cccc(C(F)(F)F)c2)CC1 lb_00719
+Cn1c(CN2CCC(c3ccccc3C(F)(F)F)CC2)nc2ccccc21 lb_00720
+CC(C)Cc1ccc(C(C)c2nc3ccccc3n2Cc2ccc(C(C)(C)C)cc2)cc1 lb_00721
+Cc1nc2cc(F)ccc2n1CCCN1CCN(Cc2ccccc2)CC1 lb_00722
+FC(F)(F)c1nc2ccccc2n1CC1CCCN1Cc1ccccc1 lb_00723
+FC(F)(F)c1nc2ccccc2n1CC1CCN(Cc2ccccc2)C1 lb_00724
+Cc1cccc(Cn2c([C@@H](N)C(C)C)nc3ccccc32)c1 lb_00725
+Cc1ccc2c(c1)nc(-c1ccc(F)cc1)n2CCc1ccccc1 lb_00726
+CC1(CC(F)(F)F)Cn2c(nc3ccccc32)-c2ccccc21 lb_00727
+CC(C)c1ccc(Cn2c(-c3ccc(F)cc3)nc3ccccc32)cc1 lb_00728
+CC(C)c1ccc(Cn2c(-c3ccccc3F)nc3ccccc32)cc1 lb_00729
+CC(C)c1ccc(-c2nc3ccccc3n2Cc2ccc(F)cc2)cc1 lb_00730
+Cc1cccc(Cn2c(CN3CCCC3)nc3ccccc32)c1 lb_00731
+CC(Cl)c1nc2ccccc2n1CCc1cccc(F)c1 lb_00732
+Cn1c(Cc2cccc3ccccc23)nc2cc(C(F)(F)F)ccc21 lb_00733
+CCC(c1ccccc1)c1nc2cc(C(F)(F)F)ccc2n1C(C)C lb_00734
+CCn1c(CNCc2cccc(F)c2)nc2ccccc21 lb_00735
+CCc1nc2ccccc2n1Cc1ccc(F)cc1CN lb_00736
+CCc1nc2ccccc2n1Cc1cc(F)ccc1CN lb_00737
+CN(Cc1nc2cc(C(F)(F)F)ccc2n1C)c1ccccc1 lb_00738
+CC(C)Cn1c(-c2ccc(N(C)C)cc2)nc2ccccc21 lb_00739
+CC(C)Cc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00740
+CC(C)Cc1nc2ccccc2n1Cc1ccccc1F lb_00741
+FC(F)(F)c1cccc(-c2cccc(-n3cnc4ccccc43)c2)c1 lb_00742
+CCCCn1c(C(=S)c2ccccc2)nc2ccccc21 lb_00743
+Fc1cccc(F)c1-c1nc2ccccc2n1CC1C=CC=C1 lb_00744
+CCN(CC)c1nc2ccccc2n1Cc1ccc(F)cc1 lb_00745
+Cc1nc2ccccc2n1C(C)C(N)c1ccc(F)cc1 lb_00746
+CCn1c(C(N)c2ccc(F)cc2)nc2ccccc21 lb_00747
+CCn1c(C(N)c2ccccc2F)nc2ccccc21 lb_00748
+CCSc1nc2ccccc2n1Cc1ccccc1F lb_00749
+CC(O)c1nc2ccccc2n1Cc1ccc(F)cc1 lb_00750
+CN(C)c1ccc(-c2nc3ccccc3n2Cc2ccccc2)cc1 lb_00751
+C=C(C)Cn1c(-c2ccc(N)cc2)nc2ccccc21 lb_00752
+COCc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00753
+CC(O)c1nc2ccccc2n1Cc1ccccc1F lb_00754
+CC(C)Cn1c(Cc2ccccc2)nc2ccccc21 lb_00755
+CC(C)Cc1nc2ccccc2n1Cc1ccccc1 lb_00756
+CC(C)c1ccc(Cn2c(Cl)nc3ccccc32)cc1 lb_00757
+Cc1cc2nc(C)n(Cc3ccc(F)cc3)c2cc1C lb_00758
+Cn1c(-c2ccc(F)cc2F)nc2ccccc21 lb_00759
+Fc1cccc(F)c1Cc1nc2ccccc2n1Cc1c(F)cccc1F lb_00760
+FC(F)=C(F)c1nc2ccccc2n1Cc1ccccc1 lb_00761
+CCCn1c(CCc2ccccc2)nc2ccccc21 lb_00762
+CC(O)c1nc2ccccc2n1Cc1ccccc1 lb_00763
+CC(=O)c1nc2ccccc2n1Cc1ccccc1 lb_00764
+C=CCn1c(CCC)nc2ccccc21 lb_00765
+COCc1nc2ccccc2n1Cc1ccccc1 lb_00766
+FC(F)(F)c1cc(-c2cn3ccccc3n2)cc(C(F)(F)F)c1 lb_00767
+CCCCCCCn1c(CCCCCC)nc2ccccc21 lb_00768
+c1ccc(Cc2nc3ccccc3n2Cc2ccccc2)cc1 lb_00769
+Cn1c(-c2ccc(F)cc2)nc2ccccc21 lb_00770
+Cn1c(-c2ccccc2F)nc2ccccc21 lb_00771
+Cn1c(-c2c(F)cccc2F)nc2ccccc21 lb_00772
+Cc1cccc(-c2nc3ccccc3n2C)c1 lb_00773
+ClCc1nc2ccccc2n1Cc1ccccc1 lb_00774
+Nc1nc2ccccc2n1CCc1ccccc1 lb_00775
+Cn1c(-c2ccccc2)nc2ccccc21 lb_00776
+Cc1nc2cc3ccccc3cc2n1C lb_00777
+CC1(N2CCC(n3c(-c4cccc(C(F)(F)F)c4)nc4ccccc43)CC2)CCCCCCC1.Cl.Cl lb_00778
+Cc1cccc(Cn2c([C@@H](N)CC(C)C)nc3cc(C(F)(F)F)ccc32)c1 lb_00779
+CCC[C@H](N)c1nc2cc(C(F)(F)F)ccc2n1Cc1cccc(C)c1 lb_00780
+Cn1cnc2ccccc21.Fc1cc(CN2CCC(F)(F)CC2)cc(C(F)(F)F)c1 lb_00781
+CN(C)CCCn1c(Cc2cccc3ccccc23)nc2cc(C(F)(F)F)ccc21 lb_00782
+CCN(CC)CCn1c(Cc2cccc3ccccc23)nc2cc(C(F)(F)F)ccc21 lb_00783
+CCCCN(CCCC)CCCn1c(-c2ccc(C)cc2C)nc2cc(C(F)(F)F)ccc21 lb_00784
+CCc1nc2ccc(C)cc2n1CCCCNc1cccc(C(F)(F)F)c1 lb_00785
+FC(F)(F)c1cccc(-c2nc3ccccc3n2C(c2ccccc2)c2nc3ccccc3[nH]2)c1 lb_00786
+CC(C)(C)c1nc2ccccc2n1Cc1cc(=O)[nH]c2c(F)c(F)ccc12 lb_00787
+Cn1c(NC(=S)N2CCN(c3cccc(C(F)(F)F)c3)CC2)nc2ccccc21 lb_00788
+FC(F)(F)c1nc2ccccc2n1Cc1ccc(-c2ccccc2)c(-c2nn[nH]n2)c1 lb_00789
+Fc1ccc(CN2CCC(Cn3c(C(F)(F)F)nc4ccccc43)CC2)cc1 lb_00790
+Fc1ccccc1CN1CCC(Cn2c(C(F)(F)F)nc3ccccc32)CC1 lb_00791
+FC(F)(F)c1nc2ccccc2n1CC1CCCCN1Cc1ccccc1 lb_00792
+CCN1CCC(N2CCC(n3c(C)nc4cc(C(F)(F)F)ccc43)CC2)CC1 lb_00793
+C[C@H](N)c1nc2cc(C(F)(F)F)ccc2n1Cc1cccc(F)c1 lb_00794
+CCCCCCCn1c(-c2cc(-c3ccc(C)cc3)nc(N)n2)nc2ccccc21 lb_00795
+CCCCCCCCn1c(-c2cc(-c3ccc(C)cc3)nc(N)n2)nc2ccccc21 lb_00796
+CCCCCCn1c(-c2cc(-c3ccc(C)cc3)nc(N)n2)nc2ccccc21 lb_00797
+Cc1cccc(Cn2c(CN3CCCCC3)nc3ccccc32)c1 lb_00798
+Cc1cccc(Cn2c(CN3CCCC3)nc3ccccc32)c1.Cl.Cl lb_00799
+Cc1ccc(Cn2c(/C=C/c3ccc(F)cc3)nc3ccccc32)cc1 lb_00800
+Cc1ccc(Cn2c(C=Cc3ccc(F)cc3)nc3ccccc32)cc1 lb_00801
+CN(C)CCn1c(Cc2cccc(F)c2)nc2ccccc21 lb_00802
+Cc1ccc(/C=C/c2nc3ccccc3n2Cc2ccccc2F)cc1 lb_00803
+CCc1nc2cc(C(F)(F)F)ccc2n1CCCN(CC)CC lb_00804
+CCN(CC)CCn1c(C(C)C)nc2cc(C(F)(F)F)ccc21 lb_00805
+CCCc1nc2cc(C(F)(F)F)ccc2n1CCN(CC)CC lb_00806
+CCC(c1ccccc1)c1nc2cc(C(F)(F)F)ccc2n1C(C)CC lb_00807
+CCCn1c(C2CCCCC2)nc2cc(C(F)(F)F)ccc21 lb_00808
+CCc1nc2ccccc2n1Cc1cc(CN)ccc1F lb_00809
+CCc1nc2ccccc2n1Cc1ccc(CN)cc1F lb_00810
+Cc1cccc(NCc2nc3ccccc3n2Cc2ccccc2)c1 lb_00811
+FC(F)(F)c1cc(-c2nc3cccnc3n2C2CCCC2)cc(C(F)(F)F)c1 lb_00812
+CCC(O)c1nc2ccccc2n1Cc1cc(C)ccc1C lb_00813
+CC(C)[C@H](N)c1nc2ccccc2n1Cc1cccc(F)c1 lb_00814
+Cc1ccc(C)c(Cn2c(CCCO)nc3ccccc32)c1 lb_00815
+C=CCn1c(-c2ccc(N(C)C)cc2)nc2ccccc21 lb_00816
+C=C(Cn1cnc2ccccc21)c1ccc(C(F)(F)F)cc1 lb_00817
+CCCCc1nc2ccccc2n1Cc1ccccc1F lb_00818
+CCc1ccc(Cn2c(C(F)(F)F)nc3cc(C)ccc32)cc1 lb_00819
+Cc1n(Cc2ccccc2)c2cc(C(F)(F)F)ccc2[n+]1C lb_00820
+CCCCc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00821
+CCCn1c(C=Cc2ccc(F)cc2)nc2ccccc21 lb_00822
+CCCn1c(/C=C/c2ccc(F)cc2)nc2ccccc21 lb_00823
+CC(Cl)c1nc2ccccc2n1CCc1ccc(F)cc1 lb_00824
+CC(Cl)c1nc2ccccc2n1CCc1ccccc1F lb_00825
+CCC(C)n1c(C(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00826
+CCn1c(CNCc2ccccc2F)nc2ccccc21 lb_00827
+CCn1c(CNCc2ccc(F)cc2)nc2ccccc21 lb_00828
+Cc1ccccc1Cn1c(CN2CCCC2)nc2ccccc21 lb_00829
+Cc1ccc(Cn2c(CCCO)nc3ccccc32)cc1 lb_00830
+CCc1nc2ccccc2n1CCCCNc1ccccc1 lb_00831
+CCCn1c(NCc2ccccc2C)nc2ccccc21 lb_00832
+Cc1ccccc1Cn1c(CCCO)nc2ccccc21 lb_00833
+Fc1ccc(Cn2c(-c3ccccn3)nc3ccccc32)cc1 lb_00834
+CCCn1c(/C=C/c2ccccc2)nc2ccccc21 lb_00835
+CC(C)Cc1nc2ccccc2n1CCc1ccccc1 lb_00836
+CCCCc1nc2ccccc2n1Cc1ccccc1 lb_00837
+CCCCn1c(Cc2ccccc2)nc2ccccc21 lb_00838
+CC(C)(C)c1ccc(-n2c(C(F)(F)F)nc3ccc(C(C)(C)C)cc32)cc1 lb_00839
+Cn1c(-c2ccc(C(F)(F)F)cc2)nc2cc(F)c(F)cc21 lb_00840
+FCCn1c(C#Cc2ccccc2)nc2ccccc21 lb_00841
+Cc1ccc(-c2nc3cc(C(F)(F)F)ccc3n2C)cc1 lb_00842
+CC(C)n1c(C(C)(C)C)nc2cc(C(F)(F)F)ccc21 lb_00843
+CC(=O)c1nc2ccccc2n1CCc1ccccc1 lb_00844
+OCc1nc2ccccc2n1Cc1ccccc1F lb_00845
+C=CCn1c(C(CC)CC)nc2ccccc21 lb_00846
+COCc1nc2ccccc2n1CCc1ccccc1 lb_00847
+CCn1c(CN(C)c2ccccc2)nc2ccccc21 lb_00848
+OCc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00849
+CC(C)(C)c1ccc2nc(-c3ccccc3)n(O)c2c1 lb_00850
+NCc1cccc(Cn2c(N)nc3ccccc32)c1 lb_00851
+CC(O)c1nc2ccccc2n1CCc1ccccc1 lb_00852
+NCc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00853
+c1ccc(CCn2c(Cc3ccccc3)nc3ccccc32)cc1 lb_00854
+NCc1nc2ccccc2n1Cc1ccccc1 lb_00855
+Fc1cc(C(F)(F)F)ccc1CCCCN1CCn2c(nc3ccccc32)C1 lb_00856
+CCC(C)[C@H](N)c1nc2cc(C(F)(F)F)ccc2n1Cc1cccc(C)c1 lb_00857
+CCc1ccc2nc(C)n(C3=NC=CCN3c3ccc(C(F)(F)F)cc3)c2c1 lb_00858
+CCc1ccc2nc(C)n(C3N=CC=CN3c3ccc(C(F)(F)F)cc3)c2c1 lb_00859
+Fc1cccc(Cn2c(N3CCC(c4ccccc4C(F)(F)F)CC3)nc3ccccc32)c1 lb_00860
+CC[C@H](C)[C@H](N)c1nc2cc(C(F)(F)F)ccc2n1Cc1cccc(C)c1 lb_00861
+FC(F)(F)c1ccc2c(c1)nc(-c1ccccc1)n2C[C@@H]1CCCN2CCCC[C@H]12 lb_00862
+CC(C)=CCCC(C)CCn1c(-c2ccccc2F)nc2ccccc21 lb_00863
+C=C[C@@H]1CN(Cc2ccc(C(F)(F)F)cc2)Cc2nc3ccccc3n21 lb_00864
+CCn1c(-c2ccccc2-c2ccc(C)cc2C)nc2cc(C(F)(F)CC)ccc21 lb_00865
+FC(F)(F)c1nc2ccccc2n1CC1CCCN(Cc2ccccc2)C1 lb_00866
+CC(C)Cc1ccc(C(C)(C)c2nc3ccccc3n2Cc2ccccc2Cl)cc1 lb_00867
+Cc1cccc(C(C)(C)C)c1NC(=O)Cn1c(-c2ccccc2)nc2ccccc21 lb_00868
+Cn1c(C(F)F)nc2ccccc21 lb_00869
+Cc1ccc(NCc2nc3ccccc3n2Cc2ccc(F)cc2F)cc1 lb_00870
+Cn1c(CN2CCN(c3ccccc3C(F)(F)F)CC2)nc2ccccc21 lb_00871
+CCC[C@H](N)c1nc2ccccc2n1Cc1cccc(C)c1 lb_00872
+Cc1cccc(Cn2c([C@@H](N)CC(C)C)nc3ccccc32)c1 lb_00873
+CCCn1c(CNCc2cccc(F)c2)nc2ccccc21 lb_00874
+CCc1nc2ccc(CCCc3cccc(C(F)(F)F)c3)cc2n1C lb_00875
+CN1CCC(c2nc3ccccc3n2Cc2cccc(F)c2)CC1 lb_00876
+Cc1ccc(Cn2c(CN3CCC(F)(F)CC3)nc3ccccc32)cc1 lb_00877
+CC(c1nc2ccccc2n1Cc1ccccc1F)N1CCCCCC1 lb_00878
+CC(c1nc2ccccc2n1Cc1ccc(F)cc1)N1CCCCCC1 lb_00879
+CCCc1nc2cc(C(F)(F)F)ccc2n1CCCN(C)C lb_00880
+CCC(C)n1c(-c2cccc(C)c2)nc2cc(C(F)(F)F)ccc21 lb_00881
+CC(C)Cn1c(C2CCCCC2)nc2cc(C(F)(F)F)ccc21 lb_00882
+CCc1nc2ccccc2n1Cc1cc(C#N)ccc1F lb_00883
+Cc1ccc(Cn2c(N3CCC(N(C)C)CC3)nc3ccccc32)cc1 lb_00884
+CC(C)(CC#N)Cc1nc2ccccc2n1Cc1ccc(Cl)cc1 lb_00885
+Cc1ccc(Cn2c(-c3cccc(C#N)c3)nc3ccccc32)cc1 lb_00886
+CC(C)Cn1c(/C=C/c2ccc(F)cc2)nc2ccccc21 lb_00887
+C=C(C)Cn1c(-c2ccc(N(C)C)cc2)nc2ccccc21 lb_00888
+CCCCCc1nc2ccccc2n1Cc1ccccc1F lb_00889
+Cc1n(Cc2ccccc2)c2cc(C(F)(F)F)ccc2[n+]1C.[Br-] lb_00890
+CCn1c(C(N)Cc2ccc(F)cc2)nc2ccccc21 lb_00891
+CCCCCc1nc2ccccc2n1Cc1c(F)cccc1F lb_00892
+Cc1cc(F)cc(C)c1CNCc1nc2ccccc2n1C lb_00893
+FC(F)(F)CC1Cn2c(nc3ccccc32)-c2ccccc21 lb_00894
+CCCCCc1nc2ccccc2n1Cc1ccc(F)cc1 lb_00895
+CC(C)Cn1c(C=Cc2ccc(F)cc2)nc2ccccc21 lb_00896
+Fc1ccc(-c2nc3ccccc3n2C/C=C/c2ccccc2)cc1 lb_00897
+Fc1ccccc1-c1nc2ccccc2n1C/C=C/c1ccccc1 lb_00898
+Fc1ccc(-c2nc3ccccc3n2Cc2cccc3ccccc23)cc1 lb_00899
+Fc1ccccc1-c1nc2ccccc2n1Cc1cccc2ccccc12 lb_00900
+Cc1cccc(-c2nc3cc(C(F)(F)F)ccc3n2C(C)C)c1 lb_00901
+CC(c1nc2ccccc2n1Cc1ccccc1)N1CCCCC1 lb_00902
+Cc1ccccc1Cn1c(CN2CCCC2)nc2ccccc21.Cl.Cl lb_00903
+Cc1ccc(Cn2c(CN3CCCC3)nc3ccccc32)cc1.Cl.Cl lb_00904
+CCCn1c(NCc2ccccc2F)nc2ccccc21 lb_00905
+CCc1ccc(-c2nc3ccccc3n2Cc2ccccc2)nc1 lb_00906
+Cc1ccccc1NCc1nc2ccccc2n1Cc1ccccc1 lb_00907
+CC(C)Cn1c(/C=C/c2ccccc2)nc2ccccc21 lb_00908
+Fc1ccc(Cn2c(Cc3ccccc3)nc3ccccc32)cc1 lb_00909
+C=C(C)Cn1c(Cc2ccccc2)nc2ccccc21 lb_00910
+CCCCCc1nc2ccccc2n1Cc1ccccc1 lb_00911
+Cn1c(-c2ccc(C(F)(F)F)cc2F)nc2cc(C(F)(F)F)ccc21 lb_00912
+Cn1c(Cc2ccc(F)cc2F)nc2ccccc21 lb_00913
+CC(C)c1ccc(Cn2c(N)nc3ccccc32)cc1 lb_00914
+Cc1cccc(CCc2nc3ccccc3n2C)c1 lb_00915
+CC(c1ccc(C(C)(C)C)cc1)c1nc2ccccc2n1C lb_00916
+C=CCn1c(-c2ccc(N)cc2)nc2ccccc21 lb_00917
+CCc1ccccc1Nc1nc2ccccc2n1CC lb_00918
+Fc1ccccc1Cn1c(C2CC2)nc2ccccc21 lb_00919
+CCCn1c(-c2ccccc2F)nc2cc3nc(-c4ccccc4F)n(CCC)c3cc21 lb_00920
+CC(C)c1nc2ccccc2n1Cc1ccccc1Cl lb_00921
+FC(F)(F)c1ccc2c(c1)ncn2Cc1ccccc1 lb_00922
+CCCCn1c(-c2cc(C(F)(F)F)cc(C(F)(F)F)c2)cnc1-c1cc(C(F)(F)F)cc(C(F)(F)F)c1 lb_00923
+CCN(CC)CCCn1c(Cc2cccc3ccccc23)nc2cc(C(F)(F)F)ccc21 lb_00924
+Cl.FC(F)(F)c1ccc2c(c1)nc(-c1ccccc1)n2CC1CCCN2CCCCC12 lb_00925
+Cc1ccc(-c2nc3ccccc3n2C(F)F)cc1 lb_00926
+Cn1c(-c2ccccc2-c2ccccc2F)nc2ccccc21 lb_00927
+Cc1cccc2nc(CN3CCC(c4ccc(C(F)(F)F)cc4)CC3)n(C)c12 lb_00928
+Cn1c(C(F)(F)F)nc2cc(C(C)(C)C)ccc21 lb_00929
+CC(C)c1nc2ccccc2n1C1=NC=CCN1c1ccc(C(F)(F)F)cc1 lb_00930
+CC(C)c1nc2ccccc2n1C1N=CC=CN1c1ccc(C(F)(F)F)cc1 lb_00931
+Cc1nc2ccc(F)cc2n1C1N=CC(F)=CN1c1ccc(C(F)(F)F)cc1 lb_00932
+Cc1nc2ccc(F)cc2n1C1N=CC=CN1c1ccc(C(F)(F)F)cc1 lb_00933
+C=Cc1nc2ccccc2n1Cc1ccccc1 lb_00934
+Cc1ccc(-c2nc3ccccc3n2C)c(C)c1 lb_00935
+CCC(c1ccccc1)c1nc2ccccc2n1C lb_00936
+FC(F)(F)c1nc2ccccc2n1CC1CCN(C/C=C/c2ccccc2)CC1 lb_00937
+CCC(C)n1c(Cc2cccc3ccccc23)nc2cc(C(F)(F)F)ccc21 lb_00938
+OCc1nc2ccccc2n1CCc1ccccc1 lb_00939
+c1ccc(CNc2nc3ccccc3n2Cc2ccccc2)cc1 lb_00940
+Cl.Cl.NCc1nc2ccccc2n1Cc1ccccc1 lb_00941
+CC(C)[C@H](N)c1nc2cc(C(F)(F)F)ccc2n1Cc1cccc(F)c1 lb_00942
+c1ccc(Cn2c(C3CC3)nc3ccccc32)cc1 lb_00943
+FC(F)(F)c1nc2ccccc2n1Cc1ccc(-c2ccccc2-c2nn[nH]n2)cc1 lb_00944
+CCC[C@H](N)c1nc2ccccc2n1Cc1cccc(F)c1 lb_00945
+CCC(C)[C@H](N)c1nc2ccccc2n1Cc1cccc(C)c1 lb_00946
+Cc1nc2cc(F)ccc2n1CCCN1CCC(c2ccc(F)cc2)CC1 lb_00947
+Cc1ccc(Cn2c(CN3CC[C@@H](F)C3)nc3ccccc32)cc1 lb_00948
+Cc1ccc(Cn2c(CN3CC[C@H](F)C3)nc3ccccc32)cc1 lb_00949
+CCC(C)(c1ccccc1-c1nc2ccccc2n1-c1ccccc1)[C@@H](C)F lb_00950
+CCC(C)c1ccc(Cn2c(-c3ccc(F)cc3)nc3ccccc32)cc1 lb_00951
+CCC(C)c1ccc(Cn2c(-c3ccccc3F)nc3ccccc32)cc1 lb_00952
+CCCc1nc2cc(C(F)(F)F)ccc2n1CCCN(CC)CC lb_00953
+CCC(C)c1nc2cc(C(F)(F)F)ccc2n1CCN(CC)CC lb_00954
+CC[C@@H](CN(C)Cc1ccccc1)n1c(C(F)(F)F)nc2ccccc21 lb_00955
+CC[C@H](CN(C)Cc1ccccc1)n1c(C(F)(F)F)nc2ccccc21 lb_00956
+CCC(CN(C)Cc1ccccc1)n1c(C(F)(F)F)nc2ccccc21 lb_00957
+CN(C)C1CCN(c2nc3ccccc3n2Cc2ccc(F)cc2)CC1 lb_00958
+CC(C)C[C@H](N)c1nc2ccccc2n1Cc1cccc(F)c1 lb_00959
+Cc1ccccc1-c1nc2ccccc2n1C lb_00960
+Cn1c(-c2ccc(-c3ccccc3)cc2)nc2ccccc21 lb_00961
+Cc1ccc(-c2nc3ccccc3n2C)cc1 lb_00962
+CCCCn1c(/C=C/c2ccc(F)cc2)nc2ccccc21 lb_00963
+Cc1cccc(/C(=N\C(F)(F)F)n2cnc3ccccc32)c1 lb_00964
+Cn1c(NCc2ccc(C(C)(C)C)cc2)nc2cc(C(F)(F)F)ccc21 lb_00965
+CCn1c(C)[n+](Cc2ccccc2)c2ccc(C(F)(F)F)cc21 lb_00966
+CCN(CC)Cn1c(C=Cc2ccc(C)cc2)nc2ccccc21 lb_00967
+CCCCn1c(C=Cc2ccc(F)cc2)nc2ccccc21 lb_00968
+CN(Cc1ccccc1)c1nc2ccccc2n1Cc1ccc(F)cc1 lb_00969
+N#CCc1nc2ccccc2n1Cc1cccc(F)c1F lb_00970
+Cc1ccc(Cn2c(CC3CCCC3)nc3ccccc32)cc1 lb_00971
+Cn1cc(-c2nc3ccccc3n2Cc2ccccc2)ccc1=O lb_00972
+FC(F)(F)c1cccc(Cn2c(C(F)(F)F)nc3cc(Cl)c(Cl)cc32)c1 lb_00973
+Cc1ccc(Cn2c(-c3ccc(C#N)cc3)nc3ccccc32)cc1 lb_00974
+Fc1ccc(-c2nc3ccccc3n2CN2CCOCC2)cc1 lb_00975
+CCCn1c(-c2ccc(F)c(C(F)(F)F)c2)nc2cc3nc(-c4ccc(F)c(C(F)(F)F)c4)n(CCC)c3cc21 lb_00976
+CN1CCN(c2nc3ccccc3n2Cc2ccc(F)cc2)CC1 lb_00977
+CCCCN(CCCC)CCCn1c(Cc2cccc3ccccc23)nc2cc(C(F)(F)F)ccc21 lb_00978
+CC(C)c1nc2ccccc2n1Cc1cccc2ccccc12 lb_00979
+Fc1ccccc1Cn1c(Cc2ccccc2)nc2ccccc21 lb_00980
+Cn1c(-c2ccccc2-c2cccc(F)c2)nc2ccccc21 lb_00981
+CCCCCCCCCCCCCCCCCc1nc2ccccc2n1Cc1ccccc1 lb_00982
+CCCCCCCn1c(Cc2ccccc2)nc2ccccc21 lb_00983
+CCCCn1c(/C=C/c2ccccc2)nc2ccccc21 lb_00984
+Fc1ccc(Cn2c(CCc3ccccc3)nc3ccccc32)cc1 lb_00985
+NCCn1c(Cc2ccc(F)cc2)nc2ccccc21 lb_00986
+CCC(O)c1nc2ccccc2n1CCc1ccccc1 lb_00987
+CN1CCN(c2nc3ccccc3n2Cc2ccccc2)CC1 lb_00988
+Cn1c(-c2ccc(N)cc2)nc2cc(C(F)(F)F)ccc21 lb_00989
+CCn1c(/C=C/c2ccc(Cl)cc2)nc2ccccc21 lb_00990
+FC(F)(F)c1cccc(C2CCN(CCCCn3cnc4ccccc43)CC2)c1 lb_00991
+Cn1c(-c2ccccc2-c2ccc(F)cc2)nc2ccccc21 lb_00992
+CC(C)n1c(-c2ccc(F)cc2)nc2ccccc21 lb_00993
+Cn1c(-c2ccccc2)nc2c(C(F)(F)F)cccc21 lb_00994
+Cc1ccccc1CCc1nc2ccccc2n1C lb_00995
+CC(C)n1c(-c2ccccc2F)nc2ccccc21 lb_00996
+CCn1c(-c2ccccc2)nc2cc(C)ccc21 lb_00997
+OCCn1c(Cc2ccccc2)nc2ccccc21 lb_00998
+Cn1c(-c2cccc(N)c2)nc2ccccc21 lb_00999

docking_pipeline/__init__.py

@@ -0,0 +1,5 @@
+"""Strict rDock-first docking pipeline."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

docking_pipeline/__main__.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def _engine_from_args(args: argparse.Namespace, validation: bool = False) -> RDockEngine:
+    from .rdock import RDockEngine, RDockRunConfig
+
+    return RDockEngine(
+        RDockRunConfig(
+            n_runs=int(getattr(args, "n_runs", 100 if validation else 50)),
+            jobs=getattr(args, "jobs", "auto"),
+            cpu_fraction=float(getattr(args, "cpu_fraction", 0.85)),
+            dock_prm=getattr(args, "dock_prm", None),
+            rbt_root=getattr(args, "rbt_root", None),
+            require_reporting_tools=validation,
+        )
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="python -m docking_pipeline", description="Strict rDock-first docking pipeline")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p = sub.add_parser("prepare-target")
+    p.add_argument("--receptor", required=True)
+    p.add_argument("--ref-ligand", required=True)
+    p.add_argument("--out", required=True)
+    p.add_argument("--rbt-root")
+    p.add_argument("--dock-prm")
+
+    p = sub.add_parser("dock-rdock")
+    p.add_argument("--target-config", required=True)
+    p.add_argument("--ligands", required=True)
+    p.add_argument("--out", required=True)
+    p.add_argument("--n-runs", type=int, default=50)
+    p.add_argument("--jobs", default="auto")
+    p.add_argument("--cpu-fraction", type=float, default=0.85)
+    p.add_argument("--dock-prm")
+    p.add_argument("--rbt-root")
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--plan-only", action="store_true")
+
+    p = sub.add_parser("validate-rdock")
+    p.add_argument("--set", choices=["astex", "dud", "rna"], required=True)
+    p.add_argument("--system")
+    p.add_argument("--system-list")
+    p.add_argument("--max-systems", type=int)
+    p.add_argument("--list-systems", action="store_true")
+    p.add_argument("--data-dir", required=True)
+    p.add_argument("--out", default="results/rdock_validation")
+    p.add_argument("--n-runs", type=int, default=100)
+    p.add_argument("--jobs", default="auto")
+    p.add_argument("--cpu-fraction", type=float, default=0.85)
+    p.add_argument("--download-url")
+    p.add_argument("--download-if-missing", action="store_true")
+    p.add_argument("--keep-work", action="store_true")
+    p.add_argument("--force", action="store_true")
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--plan-only", action="store_true")
+
+    p = sub.add_parser("run-adaptive")
+    p.add_argument("--target-config", required=True)
+    p.add_argument("--ligands", required=True, help="CSV with ligand_id,smiles and optional model_score")
+    p.add_argument("--out", required=True)
+    p.add_argument("--budget", type=int, required=True)
+    p.add_argument("--batch-size", type=int, default=16)
+    p.add_argument("--n-runs", type=int, default=50)
+    p.add_argument("--jobs", default="auto")
+    p.add_argument("--cpu-fraction", type=float, default=0.85)
+    p.add_argument("--dock-prm")
+    p.add_argument("--rbt-root")
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--plan-only", action="store_true")
+
+    p = sub.add_parser("benchmark-adaptive")
+    p.add_argument("--dataset-dir", required=True)
+    p.add_argument("--strategy", default="multifidelity_adaptive_rdock")
+    p.add_argument("--fidelity-levels", default="5,10,15,30,50")
+    p.add_argument("--cost-budget-runs", type=int, required=True)
+    p.add_argument("--adaptive-budget-ligands", type=int)
+    p.add_argument("--promotion-fraction", type=float, default=0.5)
+    p.add_argument("--min-per-cluster", type=int, default=1)
+    p.add_argument("--max-per-cluster", type=int, default=50)
+    p.add_argument("--outlier-intra-z-threshold", type=float, default=3.0)
+    p.add_argument("--score-component-filter", default="warn")
+    p.add_argument("--final-fidelity-only-hits", default="true")
+    p.add_argument("--resume", action="store_true")
+    p.add_argument("--checkpoint-every", type=int, default=1)
+    p.add_argument("--jobs", default="auto")
+    p.add_argument("--cpu-fraction", type=float, default=0.85)
+    p.add_argument("--out", required=True)
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--plan-only", action="store_true")
+
+    p = sub.add_parser("validate-dataset")
+    p.add_argument("--dataset-dir", required=True)
+    p.add_argument("--check-rdock-tools", action="store_true")
+
+    args = parser.parse_args()
+    if args.cmd == "prepare-target":
+        engine = _engine_from_args(args)
+        target = engine.prepare_target(args.receptor, args.ref_ligand, args.out)
+        print(json.dumps({"target_config": str(Path(args.out) / "target_config.yaml"), "target": target.__dict__}, indent=2))
+    elif args.cmd == "dock-rdock":
+        from .rdock import load_target_config
+
+        engine = _engine_from_args(args)
+        if args.dry_run or args.plan_only:
+            plan = {
+                "target_config": args.target_config,
+                "ligands": args.ligands,
+                "out": args.out,
+                "n_runs": args.n_runs,
+                "jobs": args.jobs,
+                "cpu_fraction": args.cpu_fraction,
+                "commands": ["rbcavity was already run during prepare-target", "rbdock chunks will be launched by --jobs"],
+            }
+            Path(args.out).mkdir(parents=True, exist_ok=True)
+            (Path(args.out) / "dock_plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8")
+            print(json.dumps(plan, indent=2))
+            return 0
+        artifacts = engine.dock_sdf(load_target_config(args.target_config), args.ligands, args.out, n_runs=args.n_runs, jobs=args.jobs)
+        print(json.dumps(artifacts.__dict__, indent=2))
+    elif args.cmd == "validate-rdock":
+        from .validation import discover_validation_systems, ensure_validation_data, validate_many
+
+        if args.set == "rna":
+            raise SystemExit("RNA rDock validation is not implemented yet; supported sets are astex and dud.")
+        data_root = ensure_validation_data(args.data_dir, args.set, args.download_url, args.download_if_missing, force=args.force)
+        if args.list_systems:
+            systems = discover_validation_systems(data_root, args.set)
+            print(json.dumps([s.__dict__ for s in systems], indent=2))
+            return 0
+        result = validate_many(
+            args.set,
+            data_root,
+            args.out,
+            system=args.system,
+            system_list=args.system_list,
+            max_systems=args.max_systems,
+            n_runs=args.n_runs,
+            jobs=args.jobs,
+            cpu_fraction=args.cpu_fraction,
+            download_url=args.download_url,
+            download_if_missing=args.download_if_missing,
+            force=args.force,
+            dry_run=args.dry_run,
+            plan_only=args.plan_only,
+        )
+        print(json.dumps(result, indent=2))
+        metrics = result.get("metrics", {}) if isinstance(result, dict) else {}
+        if metrics.get("failures"):
+            return 1
+    elif args.cmd == "run-adaptive":
+        from .adaptive import run_adaptive
+        from .rdock import load_target_config
+
+        engine = _engine_from_args(args)
+        if args.dry_run or args.plan_only:
+            plan = {
+                "target_config": args.target_config,
+                "ligands": args.ligands,
+                "out": args.out,
+                "budget": args.budget,
+                "batch_size": args.batch_size,
+                "n_runs": args.n_runs,
+                "jobs": args.jobs,
+            }
+            Path(args.out).mkdir(parents=True, exist_ok=True)
+            (Path(args.out) / "adaptive_plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8")
+            print(json.dumps(plan, indent=2))
+            return 0
+        run_dir = run_adaptive(load_target_config(args.target_config), args.ligands, args.out, args.budget, args.batch_size, engine, n_runs=args.n_runs)
+        print(json.dumps({"run_dir": str(run_dir)}, indent=2))
+    elif args.cmd == "benchmark-adaptive":
+        from .benchmark_adaptive import run_from_args
+
+        print(json.dumps(run_from_args(args), indent=2))
+    elif args.cmd == "validate-dataset":
+        from .dataset import validate_dataset_dir
+
+        print(json.dumps(validate_dataset_dir(args.dataset_dir, check_rdock_tools=args.check_rdock_tools), indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except Exception as exc:
+        from .provenance import RDockPipelineError
+
+        if isinstance(exc, RDockPipelineError):
+            raise SystemExit(str(exc))
+        raise

docking_pipeline/adaptive.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import json
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from .provenance import RDockPipelineError, require_file
+from .rdock import RDockEngine, TargetConfig
+from .sdf import best_per_ligand, parse_rdock_sdf_records, records_to_rows, split_sdf_file, write_rows_csv, write_sdf_blocks, write_sdf_records
+
+
+@dataclass
+class ScheduledBatch:
+    batch_index: int
+    ligand_ids: list[str]
+
+
+class RealDockingScheduler:
+    """Simple explicit scheduler: model ranks candidates, rDock produces ground truth."""
+
+    def __init__(self, ligands: object, budget: int, batch_size: int) -> None:
+        if hasattr(ligands, "to_dict"):
+            rows = ligands.to_dict(orient="records")  # type: ignore[call-arg]
+        else:
+            rows = list(ligands)  # type: ignore[arg-type]
+        if not rows or "ligand_id" not in rows[0] or "smiles" not in rows[0]:
+            raise RDockPipelineError("Adaptive ligand CSV must contain ligand_id and smiles columns")
+        self.rows: list[dict[str, object]] = [dict(r) for r in rows]
+        self.budget = int(budget)
+        self.batch_size = int(batch_size)
+        self.completed: set[str] = set()
+        for row in self.rows:
+            model_score = _float_or_zero(row.get("model_score", 0.0))
+            row["model_score"] = model_score
+            row["adaptive_priority"] = -model_score
+            row["actually_docked"] = False
+
+    def next_batch(self) -> ScheduledBatch | None:
+        remaining_budget = self.budget - len(self.completed)
+        if remaining_budget <= 0:
+            return None
+        active = [row for row in self.rows if str(row["ligand_id"]) not in self.completed]
+        if not active:
+            return None
+        active = sorted(active, key=lambda r: (-float(r["adaptive_priority"]), str(r["ligand_id"])))
+        ids = [str(row["ligand_id"]) for row in active[: min(self.batch_size, remaining_budget)]]
+        return ScheduledBatch(batch_index=len(self.completed) // max(1, self.batch_size), ligand_ids=ids)
+
+    def update(self, docked_scores: object) -> None:
+        if hasattr(docked_scores, "to_dict"):
+            score_rows = docked_scores.to_dict(orient="records")  # type: ignore[call-arg]
+        else:
+            score_rows = list(docked_scores)  # type: ignore[arg-type]
+        for ligand_id in [str(row["ligand_id"]) for row in score_rows]:
+            self.completed.add(ligand_id)
+            for row in self.rows:
+                if str(row["ligand_id"]) == ligand_id:
+                    row["actually_docked"] = True
+        if not score_rows:
+            return
+        scores = sorted(_float_or_zero(row.get("SCORE", 0.0)) for row in score_rows)
+        median_score = scores[len(scores) // 2]
+        for row in self.rows:
+            if str(row["ligand_id"]) not in self.completed:
+                row["adaptive_priority"] = float(row["adaptive_priority"]) + (0.001 * -median_score)
+
+    def to_dataframe(self):
+        import pandas as pd
+
+        return pd.DataFrame(self.rows)
+
+
+def _float_or_zero(value: object) -> float:
+    try:
+        return float(value)
+    except Exception:
+        return 0.0
+
+
+def _prepare_batch_sdf(ligands: pd.DataFrame, ligand_ids: list[str], out_sdf: Path) -> Path:
+    from libs.docking.prep import prepare_ligand_sdf
+
+    tmp = out_sdf.parent / "prepared"
+    tmp.mkdir(parents=True, exist_ok=True)
+    blocks: list[str] = []
+    by_id = ligands.set_index("ligand_id")
+    for ligand_id in ligand_ids:
+        smiles = str(by_id.loc[ligand_id, "smiles"])
+        sdf = prepare_ligand_sdf(ligand_id, smiles, tmp / f"{ligand_id}.sdf")
+        blocks.extend(split_sdf_file(sdf))
+    write_sdf_blocks(blocks, out_sdf)
+    return out_sdf
+
+
+def run_adaptive(
+    target_config: TargetConfig,
+    ligands_csv: str | Path,
+    out_dir: str | Path,
+    budget: int,
+    batch_size: int,
+    engine: RDockEngine,
+    n_runs: int | None = None,
+) -> Path:
+    import pandas as pd
+
+    ligands = pd.read_csv(require_file(ligands_csv, "adaptive ligand CSV"))
+    scheduler = RealDockingScheduler(ligands, budget=budget, batch_size=batch_size)
+    root = Path(out_dir)
+    for name in ("target", "ligands", "rdock", "poses", "tables", "metrics"):
+        (root / name).mkdir(parents=True, exist_ok=True)
+    shutil.copy2(target_config.receptor, root / "target" / Path(target_config.receptor).name)
+    shutil.copy2(target_config.reference_ligand, root / "target" / Path(target_config.reference_ligand).name)
+
+    batch_records = []
+    all_blocks: list[str] = []
+    while True:
+        batch = scheduler.next_batch()
+        if batch is None:
+            break
+        batch_dir = root / "rdock" / f"batch_{batch.batch_index:03d}"
+        batch_sdf = _prepare_batch_sdf(ligands, batch.ligand_ids, root / "ligands" / f"batch_{batch.batch_index:03d}.sdf")
+        artifacts = engine.dock_sdf(target_config, batch_sdf, batch_dir, n_runs=n_runs, jobs=engine.config.jobs, run_id=f"{root.name}_batch_{batch.batch_index:03d}")
+        best_df = pd.read_csv(artifacts.best_per_ligand_csv)
+        scheduler.update(best_df)
+        all_blocks.extend(split_sdf_file(artifacts.all_poses_sdf))
+        for ligand_id in batch.ligand_ids:
+            batch_records.append({"batch": batch.batch_index, "ligand_id": ligand_id})
+
+    all_poses = root / "poses" / "all_poses.sdf"
+    write_sdf_blocks(all_blocks, all_poses)
+    if all_blocks:
+        records = parse_rdock_sdf_records(all_poses)
+        best = best_per_ligand(records)
+        write_sdf_records(best, root / "poses" / "best_per_ligand.sdf")
+        score_rows = records_to_rows(records)
+        best_rows = records_to_rows(best)
+    else:
+        score_rows = []
+        best_rows = []
+        (root / "poses" / "best_per_ligand.sdf").write_text("", encoding="utf-8")
+    scheduler_df = scheduler.to_dataframe()
+    model_cols = scheduler_df[["ligand_id", "model_score", "adaptive_priority", "actually_docked"]]
+    if best_rows:
+        model_map = model_cols.set_index("ligand_id").to_dict(orient="index")
+        for row in best_rows:
+            row.update(model_map.get(str(row["ligand_id"]), {}))
+    write_rows_csv(score_rows, root / "tables" / "scores_long.csv")
+    write_rows_csv(best_rows, root / "tables" / "best_per_ligand.csv")
+    scheduler_df.to_csv(root / "tables" / "scheduler_all_ligands.csv", index=False)
+    pd.DataFrame(batch_records).to_csv(root / "tables" / "adaptive_batches.csv", index=False)
+    (root / "metrics" / "validation_metrics.json").write_text("{}", encoding="utf-8")
+    pd.DataFrame().to_csv(root / "metrics" / "enrichment.csv", index=False)
+    manifest = {
+        "engine": "real-rdock-adaptive",
+        "budget": int(budget),
+        "batch_size": int(batch_size),
+        "docked_ligand_count": int(scheduler_df["actually_docked"].sum()),
+        "undocked_ligands_are_hits": False,
+        "artifacts": {
+            "all_poses_sdf": str(all_poses),
+            "best_per_ligand_csv": str(root / "tables" / "best_per_ligand.csv"),
+            "scheduler_all_ligands_csv": str(root / "tables" / "scheduler_all_ligands.csv"),
+        },
+    }
+    (root / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+    (root / "config.yaml").write_text(f"budget: {budget}\nbatch_size: {batch_size}\n", encoding="utf-8")
+    (root / "commands.log").write_text("", encoding="utf-8")
+    for batch_log in sorted((root / "rdock").glob("batch_*/commands.log")):
+        with (root / "commands.log").open("a", encoding="utf-8") as dst:
+            dst.write(batch_log.read_text(encoding="utf-8"))
+    (root / "report.md").write_text(
+        "# Adaptive rDock Run\n\n"
+        "Model scores only schedule ligands. `best_per_ligand.csv` is built exclusively from real rDock SDF records with SCORE fields.\n",
+        encoding="utf-8",
+    )
+    return root

docking_pipeline/benchmark_adaptive.py

@@ -0,0 +1,900 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import random
+import shutil
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .dataset import read_ligand_metadata, validate_dataset_dir
+from .provenance import RDockPipelineError, probe_version, require_executable, require_file
+from .rdock import RDockEngine, RDockRunConfig, TargetConfig, load_target_config
+from .reports.plots import plot_multifidelity_outputs, plot_score_outputs
+from .sdf import ligand_id_from_block, parse_tags, split_sdf_file, write_rows_csv, write_sdf_blocks
+
+
+def _read_rows(path: str | Path) -> list[dict[str, str]]:
+    with Path(path).open("r", encoding="utf-8", newline="") as handle:
+        return list(csv.DictReader(handle))
+
+
+def _write_json(path: str | Path, payload: dict[str, Any]) -> Path:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    return target
+
+
+def _float(value: object, default: float = 0.0) -> float:
+    try:
+        text = str(value).strip()
+        if not text:
+            return default
+        return float(text)
+    except Exception:
+        return default
+
+
+def _bool_text(value: bool) -> str:
+    return "true" if value else "false"
+
+
+def _parse_levels(text: str) -> list[int]:
+    try:
+        levels = [int(part.strip()) for part in text.split(",") if part.strip()]
+    except Exception as exc:
+        raise RDockPipelineError(f"Invalid --fidelity-levels value {text!r}: {exc}") from exc
+    if not levels or sorted(levels) != levels or min(levels) <= 0:
+        raise RDockPipelineError(f"Invalid fidelity levels: {levels}")
+    return levels
+
+
+def _write_yaml_like(path: Path, payload: dict[str, Any]) -> None:
+    try:
+        import yaml
+
+        text = yaml.safe_dump(payload, sort_keys=False)
+    except Exception:
+        text = json.dumps(payload, indent=2)
+    path.write_text(text, encoding="utf-8")
+
+
+def _count_sdf(path: Path) -> int:
+    return len(split_sdf_file(path))
+
+
+def _load_input_block_map(sdf_path: Path) -> dict[str, str]:
+    block_map: dict[str, str] = {}
+    for idx, block in enumerate(split_sdf_file(sdf_path)):
+        tags = parse_tags(block)
+        ligand_id = ligand_id_from_block(block, tags, idx)
+        block_map[ligand_id] = block
+    return block_map
+
+
+def _write_selected_sdf(block_map: dict[str, str], ligand_ids: list[str], out_path: Path) -> Path:
+    missing = [ligand_id for ligand_id in ligand_ids if ligand_id not in block_map]
+    if missing:
+        raise RDockPipelineError(f"Missing {len(missing)} ligand IDs in prepared SDF: {missing[:10]}")
+    write_sdf_blocks([block_map[ligand_id] for ligand_id in ligand_ids], out_path)
+    return out_path
+
+
+def _mean(values: list[float]) -> float:
+    return sum(values) / len(values) if values else 0.0
+
+
+def _stdev(values: list[float], center: float) -> float:
+    if not values:
+        return 1.0
+    var = sum((value - center) ** 2 for value in values) / max(1, len(values))
+    return math.sqrt(var) or 1.0
+
+
+def _augment_full_rows(rows: list[dict[str, str]]) -> list[dict[str, Any]]:
+    ordered = sorted(rows, key=lambda row: (_float(row.get("SCORE"), float("inf")), str(row.get("ligand_id", ""))))
+    total = max(1, len(ordered))
+    enriched: list[dict[str, Any]] = []
+    for idx, row in enumerate(ordered, start=1):
+        item: dict[str, Any] = dict(row)
+        item["full_rank"] = idx
+        item["full_percentile"] = 100.0 if total == 1 else 100.0 * (1.0 - ((idx - 1) / (total - 1)))
+        enriched.append(item)
+    return enriched
+
+
+def _percentile_from_rank(rank: int, total: int) -> float:
+    if total <= 1:
+        return 100.0
+    return 100.0 * (1.0 - ((rank - 1) / (total - 1)))
+
+
+def _append_rank_metrics(rows: list[dict[str, Any]], full_rank_map: dict[str, int], total: int) -> list[dict[str, Any]]:
+    enriched: list[dict[str, Any]] = []
+    for row in rows:
+        item = dict(row)
+        ligand_id = str(item["ligand_id"])
+        rank = full_rank_map.get(ligand_id)
+        item["full_rank"] = rank if rank is not None else ""
+        item["full_percentile"] = _percentile_from_rank(rank, total) if rank is not None else ""
+        enriched.append(item)
+    return enriched
+
+
+def _top_overlap(full_rows: list[dict[str, Any]], sample_rows: list[dict[str, Any]], n: int) -> int:
+    full_top = {str(row["ligand_id"]) for row in full_rows[:n]}
+    ranked = sorted(sample_rows, key=lambda row: _float(row.get("final_score", row.get("SCORE")), float("inf")))
+    sample_top = {str(row["ligand_id"]) for row in ranked[:n] if str(row.get("is_final_fidelity", "")).lower() in {"true", "1"}}
+    return len(full_top & sample_top)
+
+
+def _infer_cluster_id(row: dict[str, str], index: int) -> str:
+    for key in ("cluster_id", "scaffold_id", "series_id"):
+        value = str(row.get(key, "")).strip()
+        if value:
+            return value
+    smiles = str(row.get("smiles", "")).strip()
+    if smiles:
+        return smiles[:12]
+    return f"cluster_{index:05d}"
+
+
+def _build_model_rows(rows: list[dict[str, str]]) -> list[dict[str, Any]]:
+    numeric_keys = [
+        "reference_similarity",
+        "molecular_weight",
+        "xlogp",
+        "tpsa",
+        "hbd",
+        "hba",
+        "rotatable_bonds",
+        "heavy_atom_count",
+    ]
+    features: dict[str, list[float]] = {key: [] for key in numeric_keys}
+    parsed: list[dict[str, Any]] = []
+    for idx, row in enumerate(rows):
+        item: dict[str, Any] = dict(row)
+        item["cluster_id"] = _infer_cluster_id(row, idx)
+        scaffold_match = str(row.get("scaffold_match", "")).strip().lower() in {"1", "true", "yes", "y"}
+        is_reference = str(row.get("is_reference", "")).strip().lower() in {"1", "true", "yes", "y"}
+        item["scaffold_match_num"] = 1.0 if scaffold_match else 0.0
+        item["is_reference_num"] = 1.0 if is_reference else 0.0
+        sim = _float(row.get("reference_similarity"), 0.0)
+        model_score = _float(row.get("model_score"), sim + 0.1 * item["scaffold_match_num"] + 0.05 * item["is_reference_num"])
+        item["model_score"] = model_score
+        for key in numeric_keys:
+            value = _float(row.get(key), 0.0)
+            item[key] = value
+            features[key].append(value)
+        parsed.append(item)
+    means = {key: _mean(values) for key, values in features.items()}
+    stdevs = {key: _stdev(values, means[key]) for key, values in features.items()}
+    for item in parsed:
+        item["feature_vector"] = [
+            (_float(item[key]) - means[key]) / stdevs[key]
+            for key in numeric_keys
+        ] + [float(item["scaffold_match_num"]), float(item["is_reference_num"])]
+    return parsed
+
+
+def _distance(a: list[float], b: list[float]) -> float:
+    return math.sqrt(sum((x - y) ** 2 for x, y in zip(a, b)))
+
+
+def _plan_level_counts(library_size: int, levels: list[int], budget_runs: int, promotion_fraction: float) -> list[int]:
+    if not 0.0 < promotion_fraction <= 1.0:
+        raise RDockPipelineError(f"promotion_fraction must be in (0, 1], got {promotion_fraction}")
+    if library_size <= 0:
+        return [0 for _ in levels]
+    best_counts = [0 for _ in levels]
+    for final_count in range(1, library_size + 1):
+        counts = [0 for _ in levels]
+        counts[-1] = final_count
+        for idx in range(len(levels) - 2, -1, -1):
+            counts[idx] = min(library_size, max(counts[idx + 1], int(math.ceil(counts[idx + 1] / promotion_fraction))))
+        cost = sum(count * level for count, level in zip(counts, levels))
+        if cost <= budget_runs:
+            best_counts = counts
+        else:
+            break
+    if not any(best_counts):
+        base = min(library_size, max(1, budget_runs // levels[0]))
+        best_counts[0] = base
+        for idx in range(1, len(levels)):
+            best_counts[idx] = 0
+    return best_counts
+
+
+def _select_diverse(rows: list[dict[str, Any]], target_count: int, min_per_cluster: int, max_per_cluster: int) -> list[dict[str, Any]]:
+    if target_count <= 0 or not rows:
+        return []
+    cluster_counts: dict[str, int] = {}
+    selected: list[dict[str, Any]] = []
+    cluster_buckets: dict[str, list[dict[str, Any]]] = {}
+    for row in rows:
+        cluster_buckets.setdefault(str(row["cluster_id"]), []).append(row)
+    for cluster_id in sorted(cluster_buckets):
+        bucket = cluster_buckets[cluster_id]
+        take = min(len(bucket), min_per_cluster, max_per_cluster, target_count - len(selected))
+        selected.extend(bucket[:take])
+        cluster_counts[cluster_id] = take
+        if len(selected) >= target_count:
+            return selected[:target_count]
+    for row in rows:
+        cluster_id = str(row["cluster_id"])
+        current = cluster_counts.get(cluster_id, 0)
+        if current >= max_per_cluster:
+            continue
+        if any(str(existing["ligand_id"]) == str(row["ligand_id"]) for existing in selected):
+            continue
+        selected.append(row)
+        cluster_counts[cluster_id] = current + 1
+        if len(selected) >= target_count:
+            break
+    return selected[:target_count]
+
+
+@dataclass
+class MultiFidelityConfig:
+    strategy: str
+    fidelity_levels: list[int]
+    cost_budget_runs: int
+    adaptive_budget_ligands: int | None
+    promotion_fraction: float
+    min_per_cluster: int
+    max_per_cluster: int
+    outlier_intra_z_threshold: float
+    score_component_filter: str
+    final_fidelity_only_hits: bool
+    checkpoint_every: int
+    jobs: int | str
+    cpu_fraction: float
+    resume: bool
+
+
+class MultiFidelityAdaptiveRunner:
+    def __init__(
+        self,
+        dataset_dir: str | Path,
+        out_dir: str | Path,
+        engine: RDockEngine,
+        config: MultiFidelityConfig,
+    ) -> None:
+        self.dataset_dir = Path(dataset_dir)
+        self.out_dir = Path(out_dir)
+        self.engine = engine
+        self.config = config
+        self.dataset_validation = validate_dataset_dir(self.dataset_dir, check_rdock_tools=False)
+        self.manifest = self.dataset_validation["manifest"]
+        self.target_config = load_target_config(self.dataset_dir / "target" / "rdock_prm" / "target_config.yaml")
+        self.ligands_sdf = require_file(self.dataset_dir / "ligands" / "all_ligands.sdf", "dataset ligand library")
+        metadata_path = self.dataset_dir / "ligands" / "ligand_metadata.csv"
+        if metadata_path.exists():
+            metadata_rows = read_ligand_metadata(metadata_path)
+        else:
+            metadata_rows = [{"ligand_id": ligand_id, "smiles": ""} for ligand_id in self._load_block_map()]
+        self.model_rows = _build_model_rows(metadata_rows)
+        self.model_by_id = {str(row["ligand_id"]): row for row in self.model_rows}
+        self.block_map = self._load_block_map()
+        self.final_level = self.config.fidelity_levels[-1]
+        self.trace_rows: list[dict[str, Any]] = []
+        self.promotion_rows: list[dict[str, Any]] = []
+        self.state_by_id: dict[str, dict[str, Any]] = {}
+        self.training_time_total = 0.0
+        self.docking_time_total = 0.0
+        self.overhead_time_total = 0.0
+        self._init_state()
+
+    def _load_block_map(self) -> dict[str, str]:
+        return _load_input_block_map(Path(self.ligands_sdf))
+
+    def _init_state(self) -> None:
+        for row in self.model_rows:
+            ligand_id = str(row["ligand_id"])
+            self.state_by_id[ligand_id] = {
+                "ligand_id": ligand_id,
+                "cluster_id": str(row["cluster_id"]),
+                "model_score": float(row["model_score"]),
+                "surrogate_score": float(row["model_score"]),
+                "selected_fidelity_runs": 0,
+                "current_best_score": "",
+                "current_best_score_level": "",
+                "final_score": "",
+                "is_final_fidelity": False,
+                "n_rdock_runs_total_spent": 0,
+                "promoted_from_level": "",
+                "promoted_to_level": "",
+                "promotion_reason": "",
+                "batch_id": "",
+                "rdock_success": False,
+                "failed_reason": "",
+                "timing_docking_seconds": 0.0,
+                "timing_training_seconds": 0.0,
+                "intra_outlier": False,
+                "score_outlier": False,
+                "component_warning": "",
+            }
+
+    def _write_checkpoint(self, name: str, payload: dict[str, Any]) -> None:
+        checkpoint_dir = self.out_dir / "checkpoints"
+        checkpoint_dir.mkdir(parents=True, exist_ok=True)
+        _write_json(checkpoint_dir / f"{name}.json", payload)
+
+    def _prepare_output_layout(self) -> None:
+        for name in ("target", "ligands", "rdock", "poses", "tables", "metrics", "plots", "checkpoints"):
+            (self.out_dir / name).mkdir(parents=True, exist_ok=True)
+        target_dir = self.out_dir / "target"
+        shutil.copy2(require_file(self.dataset_dir / "target" / "target.mol2", "dataset target.mol2"), target_dir / "target.mol2")
+        shutil.copy2(require_file(self.dataset_dir / "target" / "reference_ligand.sdf", "dataset reference_ligand.sdf"), target_dir / "reference_ligand.sdf")
+        prm_dir = target_dir / "rdock_prm"
+        prm_dir.mkdir(parents=True, exist_ok=True)
+        for path in (self.dataset_dir / "target" / "rdock_prm").iterdir():
+            if path.is_file():
+                shutil.copy2(path, prm_dir / path.name)
+        shutil.copy2(self.ligands_sdf, self.out_dir / "ligands" / "all_ligands.sdf")
+
+    def _run_full_docking(self) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+        full_dir = self.out_dir / "full_docking"
+        full_dir.mkdir(parents=True, exist_ok=True)
+        start = time.time()
+        artifacts = self.engine.dock_sdf(
+            self.target_config,
+            self.ligands_sdf,
+            full_dir,
+            n_runs=self.final_level,
+            jobs=self.config.jobs,
+            run_id=f"{self.out_dir.name}_full",
+            resume=self.config.resume,
+        )
+        elapsed = time.time() - start
+        rows = _augment_full_rows(_read_rows(artifacts.best_per_ligand_csv))
+        write_rows_csv(rows, self.out_dir / "tables" / "full_docking_scores.csv")
+        metrics = {
+            "library_size": _count_sdf(Path(self.ligands_sdf)),
+            "successful_ligands": len(rows),
+            "failed_ligands": max(0, _count_sdf(Path(self.ligands_sdf)) - len(rows)),
+            "pose_count": _count_sdf(Path(artifacts.all_poses_sdf)),
+            "best_SCORE": _float(rows[0]["SCORE"]) if rows else None,
+            "full_docking_seconds": elapsed,
+            "n_runs": self.final_level,
+            "best_ligand_id": rows[0]["ligand_id"] if rows else None,
+        }
+        _write_json(self.out_dir / "metrics" / "rdock_metrics.json", metrics)
+        return rows, metrics
+
+    def _run_single_fidelity_adaptive(self, count: int) -> tuple[list[dict[str, Any]], float]:
+        if count <= 0:
+            return [], 0.0
+        ordered = sorted(
+            self.model_rows,
+            key=lambda row: (-float(row["model_score"]), str(row["cluster_id"]), str(row["ligand_id"])),
+        )
+        selected = _select_diverse(ordered, count, self.config.min_per_cluster, self.config.max_per_cluster)
+        selected_ids = [str(row["ligand_id"]) for row in selected]
+        run_dir = self.out_dir / "single_fidelity_adaptive"
+        run_dir.mkdir(parents=True, exist_ok=True)
+        sdf_path = self.out_dir / "ligands" / "single_fidelity_adaptive.sdf"
+        _write_selected_sdf(self.block_map, selected_ids, sdf_path)
+        start = time.time()
+        self.engine.dock_sdf(
+            self.target_config,
+            sdf_path,
+            run_dir,
+            n_runs=self.final_level,
+            jobs=self.config.jobs,
+            run_id=f"{self.out_dir.name}_single",
+            resume=self.config.resume,
+        )
+        elapsed = time.time() - start
+        rows = [dict(row) for row in _read_rows(run_dir / "tables" / "best_per_ligand.csv")]
+        for row in rows:
+            row["is_final_fidelity"] = True
+            row["final_score"] = row.get("SCORE", "")
+        write_rows_csv(rows, self.out_dir / "tables" / "single_fidelity_adaptive_scores.csv")
+        return rows, elapsed
+
+    def _run_random_baseline(self, cost_budget_runs: int) -> tuple[list[dict[str, Any]], float]:
+        count = max(1, cost_budget_runs // self.final_level)
+        population = [str(row["ligand_id"]) for row in self.model_rows]
+        selected_ids = random.Random(42).sample(population, min(len(population), count))
+        run_dir = self.out_dir / "random_baseline"
+        run_dir.mkdir(parents=True, exist_ok=True)
+        sdf_path = self.out_dir / "ligands" / "random_baseline.sdf"
+        _write_selected_sdf(self.block_map, selected_ids, sdf_path)
+        start = time.time()
+        self.engine.dock_sdf(
+            self.target_config,
+            sdf_path,
+            run_dir,
+            n_runs=self.final_level,
+            jobs=self.config.jobs,
+            run_id=f"{self.out_dir.name}_random",
+            resume=self.config.resume,
+        )
+        elapsed = time.time() - start
+        rows = [dict(row) for row in _read_rows(run_dir / "tables" / "best_per_ligand.csv")]
+        for row in rows:
+            row["is_final_fidelity"] = True
+            row["final_score"] = row.get("SCORE", "")
+            row["n_rdock_runs_total_spent"] = self.final_level
+        write_rows_csv(rows, self.out_dir / "tables" / "random_baseline_scores.csv")
+        return rows, elapsed
+
+    def _penalize_rows(self, rows: list[dict[str, Any]], level: int) -> list[dict[str, Any]]:
+        score_values = [_float(row.get("SCORE"), float("nan")) for row in rows if str(row.get("rdock_success", "")).lower() in {"true", "1"}]
+        intra_values = [_float(row.get("SCORE.INTRA"), float("nan")) for row in rows if str(row.get("rdock_success", "")).lower() in {"true", "1"}]
+        score_mean = _mean(score_values)
+        intra_mean = _mean(intra_values)
+        score_sd = _stdev(score_values, score_mean)
+        intra_sd = _stdev(intra_values, intra_mean)
+        output: list[dict[str, Any]] = []
+        for row in rows:
+            item = dict(row)
+            score = _float(item.get("SCORE"), float("inf"))
+            intra = _float(item.get("SCORE.INTRA"), 0.0)
+            score_z = (score - score_mean) / score_sd if math.isfinite(score) else 0.0
+            intra_z = (intra - intra_mean) / intra_sd if math.isfinite(intra) else 0.0
+            dominant_intra = abs(intra) > max(10.0, abs(score) * 1.5)
+            intra_outlier = intra_z < (-abs(self.config.outlier_intra_z_threshold)) or dominant_intra
+            score_outlier = score_z < -4.0
+            penalty = 0.0
+            warnings: list[str] = []
+            if intra_outlier:
+                penalty += min(25.0, abs(intra_z) * 2.0 if math.isfinite(intra_z) else 10.0)
+                warnings.append("intra_outlier")
+            if score_outlier:
+                penalty += 5.0
+                warnings.append("score_outlier")
+            item["intra_outlier"] = intra_outlier
+            item["score_outlier"] = score_outlier
+            item["component_warning"] = ",".join(warnings)
+            item["ranking_score"] = score + penalty
+            item["selected_fidelity_runs"] = level
+            output.append(item)
+        return output
+
+    def _promotion_priority(self, row: dict[str, Any]) -> float:
+        ranking_score = _float(row.get("ranking_score"), float("inf"))
+        model_score = _float(row.get("model_score"), 0.0)
+        surrogate_score = _float(row.get("surrogate_score"), 0.0)
+        return ranking_score - (0.5 * surrogate_score) - (0.25 * model_score)
+
+    def _update_surrogate(self, observed_rows: list[dict[str, Any]]) -> float:
+        start = time.time()
+        observed = [(str(row["ligand_id"]), _float(row.get("ranking_score"), float("inf"))) for row in observed_rows]
+        if not observed:
+            return 0.0
+        observed_ids = [ligand_id for ligand_id, _ in observed]
+        for row in self.model_rows:
+            ligand_id = str(row["ligand_id"])
+            if ligand_id in observed_ids:
+                row["surrogate_score"] = -_float(next(item[1] for item in observed if item[0] == ligand_id))
+                continue
+            neighbors: list[tuple[float, float]] = []
+            for observed_id, ranking_score in observed:
+                ref = self.model_by_id[observed_id]
+                dist = _distance(row["feature_vector"], ref["feature_vector"])
+                neighbors.append((dist, ranking_score))
+            neighbors.sort(key=lambda item: item[0])
+            top = neighbors[: min(16, len(neighbors))]
+            weights = [1.0 / (1.0 + dist) for dist, _ in top]
+            total_weight = sum(weights) or 1.0
+            predicted = sum(weight * score for weight, (_, score) in zip(weights, top)) / total_weight
+            row["surrogate_score"] = -predicted
+        return time.time() - start
+
+    def _record_level_rows(self, level: int, batch_id: int, rows: list[dict[str, Any]], level_seconds: float, training_seconds: float) -> None:
+        level_rows: list[dict[str, Any]] = []
+        for row in rows:
+            ligand_id = str(row["ligand_id"])
+            state = self.state_by_id[ligand_id]
+            raw_score = row.get("SCORE", "")
+            current_best = state["current_best_score"]
+            if current_best == "" or _float(raw_score, float("inf")) < _float(current_best, float("inf")):
+                state["current_best_score"] = raw_score
+                state["current_best_score_level"] = level
+            state["selected_fidelity_runs"] = level
+            state["surrogate_score"] = self.model_by_id[ligand_id].get("surrogate_score", state["surrogate_score"])
+            state["n_rdock_runs_total_spent"] = int(state["n_rdock_runs_total_spent"]) + level
+            state["batch_id"] = batch_id
+            state["rdock_success"] = str(row.get("rdock_success", True)).lower() in {"true", "1"}
+            state["failed_reason"] = row.get("failed_reason", "")
+            state["timing_docking_seconds"] = _float(state["timing_docking_seconds"]) + level_seconds / max(1, len(rows))
+            state["timing_training_seconds"] = _float(state["timing_training_seconds"]) + training_seconds / max(1, len(rows))
+            state["intra_outlier"] = row.get("intra_outlier", False)
+            state["score_outlier"] = row.get("score_outlier", False)
+            state["component_warning"] = row.get("component_warning", "")
+            if level == self.final_level and state["rdock_success"]:
+                state["final_score"] = raw_score
+                state["is_final_fidelity"] = True
+            merged = dict(state)
+            merged.update({key: value for key, value in row.items() if key not in merged})
+            self.trace_rows.append(merged)
+            level_rows.append(merged)
+        write_rows_csv(level_rows, self.out_dir / "tables" / f"fidelity_level_{level}_scores.csv")
+
+    def _run_level(self, level: int, level_index: int, selected_ids: list[str]) -> list[dict[str, Any]]:
+        level_dir = self.out_dir / "rdock" / f"fidelity_{level:03d}"
+        selection_path = level_dir / "selection.json"
+        level_dir.mkdir(parents=True, exist_ok=True)
+        if not (self.config.resume and selection_path.exists()):
+            _write_json(
+                selection_path,
+                {
+                    "level": level,
+                    "level_index": level_index,
+                    "ligand_ids": selected_ids,
+                },
+            )
+        sdf_path = self.out_dir / "ligands" / f"fidelity_{level:03d}.sdf"
+        if not (self.config.resume and sdf_path.exists() and _count_sdf(sdf_path) == len(selected_ids)):
+            _write_selected_sdf(self.block_map, selected_ids, sdf_path)
+        start = time.time()
+        self.engine.dock_sdf(
+            self.target_config,
+            sdf_path,
+            level_dir,
+            n_runs=level,
+            jobs=self.config.jobs,
+            run_id=f"{self.out_dir.name}_fidelity_{level:03d}",
+            resume=self.config.resume,
+        )
+        level_seconds = time.time() - start
+        self.docking_time_total += level_seconds
+        best_rows = []
+        success_rows = {str(row["ligand_id"]): dict(row) for row in _read_rows(level_dir / "tables" / "best_per_ligand.csv")}
+        for ligand_id in selected_ids:
+            row = success_rows.get(ligand_id, {"ligand_id": ligand_id, "rdock_success": False, "failed_reason": "missing_best_pose"})
+            row.setdefault("model_score", self.model_by_id[ligand_id]["model_score"])
+            row.setdefault("cluster_id", self.model_by_id[ligand_id]["cluster_id"])
+            row.setdefault("surrogate_score", self.model_by_id[ligand_id].get("surrogate_score", self.model_by_id[ligand_id]["model_score"]))
+            row["rdock_success"] = bool(success_rows.get(ligand_id))
+            best_rows.append(row)
+        penalized = self._penalize_rows(best_rows, level)
+        training_seconds = self._update_surrogate(penalized)
+        self.training_time_total += training_seconds
+        self._record_level_rows(level, level_index, penalized, level_seconds, training_seconds)
+        return penalized
+
+    def _promotion_reason(self, row: dict[str, Any]) -> str:
+        reasons = [f"ranking_score={row.get('ranking_score')}", f"cluster={row.get('cluster_id')}"]
+        if row.get("component_warning"):
+            reasons.append(str(row["component_warning"]))
+        return ";".join(reasons)
+
+    def _promote(
+        self,
+        rows: list[dict[str, Any]],
+        current_level: int,
+        next_level: int,
+        target_count: int,
+    ) -> list[str]:
+        successful = [row for row in rows if str(row.get("rdock_success", "")).lower() in {"true", "1"}]
+        ordered = sorted(
+            successful,
+            key=lambda row: (
+                self._promotion_priority(row),
+                -_float(row.get("model_score"), 0.0),
+                str(row.get("cluster_id", "")),
+                str(row.get("ligand_id", "")),
+            ),
+        )
+        chosen_rows = _select_diverse(ordered, target_count, self.config.min_per_cluster, self.config.max_per_cluster)
+        promoted_ids = [str(row["ligand_id"]) for row in chosen_rows]
+        for row in ordered:
+            ligand_id = str(row["ligand_id"])
+            decision = {
+                "ligand_id": ligand_id,
+                "cluster_id": row.get("cluster_id", ""),
+                "from_level": current_level,
+                "to_level": next_level if ligand_id in promoted_ids else "",
+                "promoted": ligand_id in promoted_ids,
+                "promotion_reason": self._promotion_reason(row) if ligand_id in promoted_ids else "not selected",
+                "ranking_score": row.get("ranking_score", ""),
+                "SCORE": row.get("SCORE", ""),
+                "SCORE.INTER": row.get("SCORE.INTER", ""),
+                "SCORE.INTRA": row.get("SCORE.INTRA", ""),
+                "component_warning": row.get("component_warning", ""),
+            }
+            self.promotion_rows.append(decision)
+            state = self.state_by_id[ligand_id]
+            if ligand_id in promoted_ids:
+                state["promoted_from_level"] = current_level
+                state["promoted_to_level"] = next_level
+                state["promotion_reason"] = decision["promotion_reason"]
+        return promoted_ids
+
+    def _initial_selection(self, target_count: int) -> list[str]:
+        ordered = sorted(
+            self.model_rows,
+            key=lambda row: (-float(row["model_score"]), str(row["cluster_id"]), str(row["ligand_id"])),
+        )
+        selected = _select_diverse(ordered, target_count, self.config.min_per_cluster, self.config.max_per_cluster)
+        return [str(row["ligand_id"]) for row in selected]
+
+    def run_multifidelity(self) -> dict[str, Any]:
+        self._prepare_output_layout()
+        full_rows, full_metrics = self._run_full_docking()
+        single_count = max(1, self.config.cost_budget_runs // self.final_level)
+        single_rows, single_seconds = self._run_single_fidelity_adaptive(single_count)
+        random_rows, random_seconds = self._run_random_baseline(self.config.cost_budget_runs)
+
+        level_counts = _plan_level_counts(
+            library_size=_count_sdf(Path(self.ligands_sdf)),
+            levels=self.config.fidelity_levels,
+            budget_runs=self.config.cost_budget_runs,
+            promotion_fraction=self.config.promotion_fraction,
+        )
+        if self.config.adaptive_budget_ligands is not None and level_counts:
+            level_counts[0] = min(level_counts[0], int(self.config.adaptive_budget_ligands))
+        selected_ids = self._initial_selection(level_counts[0] if level_counts else 0)
+        observed_rows: list[dict[str, Any]] = []
+        per_level_summary: list[dict[str, Any]] = []
+        for idx, level in enumerate(self.config.fidelity_levels):
+            if not selected_ids:
+                break
+            level_rows = self._run_level(level, idx, selected_ids)
+            observed_rows.extend(level_rows)
+            outlier_count = sum(1 for row in level_rows if str(row.get("intra_outlier", "")).lower() in {"true", "1"})
+            successful_count = sum(1 for row in level_rows if str(row.get("rdock_success", "")).lower() in {"true", "1"})
+            per_level_summary.append(
+                {
+                    "fidelity_level": level,
+                    "screened_ligands": len(selected_ids),
+                    "successful_ligands": successful_count,
+                    "failed_ligands": len(selected_ids) - successful_count,
+                    "outlier_count": outlier_count,
+                }
+            )
+            if idx + 1 < len(self.config.fidelity_levels):
+                selected_ids = self._promote(level_rows, level, self.config.fidelity_levels[idx + 1], level_counts[idx + 1])
+                if idx % max(1, self.config.checkpoint_every) == 0:
+                    self._write_checkpoint(
+                        f"level_{level:03d}",
+                        {
+                            "level": level,
+                            "selected_ids": selected_ids,
+                            "summary": per_level_summary[-1],
+                        },
+                    )
+            else:
+                selected_ids = []
+
+        write_rows_csv(self.trace_rows, self.out_dir / "tables" / "multifidelity_trace.csv")
+        write_rows_csv(self.promotion_rows, self.out_dir / "tables" / "promotion_decisions.csv")
+
+        final_rows = [dict(state) for state in self.state_by_id.values() if not self.config.final_fidelity_only_hits or bool(state["is_final_fidelity"])]
+        final_rows = [row for row in final_rows if row.get("final_score", "") != "" or not self.config.final_fidelity_only_hits]
+        final_rows.sort(key=lambda row: (_float(row.get("final_score", row.get("current_best_score")), float("inf")), str(row.get("ligand_id", ""))))
+        write_rows_csv(final_rows, self.out_dir / "tables" / "final_hits.csv")
+
+        full_rank_map = {str(row["ligand_id"]): int(row["full_rank"]) for row in full_rows}
+        random_ranked = _append_rank_metrics(random_rows, full_rank_map, len(full_rows))
+        single_ranked = _append_rank_metrics(single_rows, full_rank_map, len(full_rows))
+        final_ranked = _append_rank_metrics(final_rows, full_rank_map, len(full_rows))
+        write_rows_csv(random_ranked, self.out_dir / "tables" / "random_baseline_scores.csv")
+        write_rows_csv(single_ranked, self.out_dir / "tables" / "single_fidelity_adaptive_scores.csv")
+        write_rows_csv(final_ranked, self.out_dir / "tables" / "multifidelity_final_hits_ranked.csv")
+
+        full_best = full_rows[0] if full_rows else None
+        final_only_rows = [row for row in final_ranked if str(row.get("is_final_fidelity", "")).lower() in {"true", "1"}]
+        mf_best = final_only_rows[0] if final_only_rows else None
+        random_best = min(random_ranked, key=lambda row: _float(row.get("final_score", row.get("SCORE")), float("inf"))) if random_ranked else None
+        single_best = min(single_ranked, key=lambda row: _float(row.get("final_score", row.get("SCORE")), float("inf"))) if single_ranked else None
+        total_runs_spent = sum(int(_float(row.get("n_rdock_runs_total_spent"), 0.0)) for row in self.state_by_id.values())
+        metrics = {
+            "strategy": self.config.strategy,
+            "dataset_dir": str(self.dataset_dir),
+            "target_id": str(self.manifest.get("pdb_id", self.out_dir.name)).lower(),
+            "fidelity_levels": self.config.fidelity_levels,
+            "cost_budget_runs": self.config.cost_budget_runs,
+            "best_final_SCORE_found_by_multifidelity": _float(mf_best.get("final_score")) if mf_best else None,
+            "best_final_SCORE_found_by_random_at_same_cost": _float(random_best.get("final_score", random_best.get("SCORE"))) if random_best else None,
+            "best_SCORE_in_full_docking": _float(full_best.get("SCORE")) if full_best else None,
+            "best_final_SCORE_found_by_single_fidelity": _float(single_best.get("final_score", single_best.get("SCORE"))) if single_best else None,
+            "multifidelity_percentile_vs_full": _float(mf_best.get("full_percentile")) if mf_best else None,
+            "random_percentile_vs_full": _float(random_best.get("full_percentile")) if random_best else None,
+            "single_fidelity_percentile_vs_full": _float(single_best.get("full_percentile")) if single_best else None,
+            "top1_overlap_vs_full": _top_overlap(full_rows, final_ranked, 1),
+            "top5_overlap_vs_full": _top_overlap(full_rows, final_ranked, 5),
+            "top10_overlap_vs_full": _top_overlap(full_rows, final_ranked, 10),
+            "total_rdock_runs_spent": total_runs_spent,
+            "walltime_total_seconds": self.docking_time_total + self.training_time_total + self.overhead_time_total + full_metrics["full_docking_seconds"] + random_seconds + single_seconds,
+            "docking_time_seconds": self.docking_time_total,
+            "training_time_seconds": self.training_time_total,
+            "overhead_time_seconds": self.overhead_time_total,
+            "number_of_ligands_screened_at_each_fidelity": per_level_summary,
+            "number_promoted_between_levels": {
+                f"{current}->{next_level}": sum(1 for row in self.promotion_rows if row.get("promoted") and row.get("from_level") == current and row.get("to_level") == next_level)
+                for current, next_level in zip(self.config.fidelity_levels[:-1], self.config.fidelity_levels[1:])
+            },
+            "success_failure_rate_per_fidelity": per_level_summary,
+            "outlier_count_per_fidelity": {str(row["fidelity_level"]): row["outlier_count"] for row in per_level_summary},
+            "adaptive_gain_over_random": (
+                _float(random_best.get("full_percentile")) - _float(mf_best.get("full_percentile"))
+                if mf_best and random_best
+                else None
+            ),
+            "final_hits_count": len(final_only_rows),
+            "full_docking_success_count": len(full_rows),
+            "random_final_count": len(random_ranked),
+            "single_fidelity_final_count": len(single_ranked),
+        }
+        _write_json(self.out_dir / "metrics" / "adaptive_benchmark_metrics.json", metrics)
+        _write_json(self.out_dir / "metrics" / "validation_metrics.json", metrics)
+
+        plots = []
+        plots.extend(plot_score_outputs(self.out_dir / "tables" / "full_docking_scores.csv", self.out_dir / "plots", title_prefix="full docking"))
+        plots.extend(
+            plot_multifidelity_outputs(
+                self.out_dir / "tables" / "multifidelity_trace.csv",
+                self.out_dir / "tables" / "final_hits.csv",
+                self.out_dir / "tables" / "random_baseline_scores.csv",
+                self.out_dir / "tables" / "full_docking_scores.csv",
+                self.out_dir / "metrics" / "adaptive_benchmark_metrics.json",
+                self.out_dir / "plots",
+            )
+        )
+
+        report_lines = [
+            f"# benchmark-adaptive: {self.manifest.get('pdb_id', self.out_dir.name)}",
+            "",
+            "## Input",
+            f"- dataset_dir: `{self.dataset_dir}`",
+            f"- strategy: `{self.config.strategy}`",
+            f"- fidelity_levels: `{','.join(str(v) for v in self.config.fidelity_levels)}`",
+            f"- cost_budget_runs: `{self.config.cost_budget_runs}`",
+            f"- jobs: `{self.config.jobs}`",
+            f"- cpu_fraction: `{self.config.cpu_fraction}`",
+            "",
+            "## Metrics",
+        ]
+        for key in [
+            "best_final_SCORE_found_by_multifidelity",
+            "best_final_SCORE_found_by_random_at_same_cost",
+            "best_final_SCORE_found_by_single_fidelity",
+            "best_SCORE_in_full_docking",
+            "multifidelity_percentile_vs_full",
+            "random_percentile_vs_full",
+            "single_fidelity_percentile_vs_full",
+            "total_rdock_runs_spent",
+            "walltime_total_seconds",
+            "docking_time_seconds",
+            "training_time_seconds",
+            "adaptive_gain_over_random",
+        ]:
+            report_lines.append(f"- {key}: `{metrics.get(key)}`")
+        report_lines.extend(["", "## Plots"])
+        report_lines.extend([f"- `{path}`" for path in plots] or ["- No plots generated"])
+        report_lines.extend(["", "## Top Final Hits"])
+        for row in final_only_rows[:20]:
+            report_lines.append(
+                f"- `{row.get('ligand_id')}` final_score `{row.get('final_score')}` "
+                f"cluster `{row.get('cluster_id')}` runs_spent `{row.get('n_rdock_runs_total_spent')}` "
+                f"warning `{row.get('component_warning', '')}`"
+            )
+        (self.out_dir / "report.md").write_text("\n".join(report_lines) + "\n", encoding="utf-8")
+
+        manifest = {
+            "engine": "benchmark-adaptive",
+            "strategy": self.config.strategy,
+            "dataset_dir": str(self.dataset_dir),
+            "artifacts": {
+                "target_dir": str(self.out_dir / "target"),
+                "ligands_sdf": str(self.out_dir / "ligands" / "all_ligands.sdf"),
+                "full_docking_scores": str(self.out_dir / "tables" / "full_docking_scores.csv"),
+                "random_baseline_scores": str(self.out_dir / "tables" / "random_baseline_scores.csv"),
+                "single_fidelity_scores": str(self.out_dir / "tables" / "single_fidelity_adaptive_scores.csv"),
+                "multifidelity_trace": str(self.out_dir / "tables" / "multifidelity_trace.csv"),
+                "promotion_decisions": str(self.out_dir / "tables" / "promotion_decisions.csv"),
+                "final_hits": str(self.out_dir / "tables" / "final_hits.csv"),
+                "metrics_json": str(self.out_dir / "metrics" / "adaptive_benchmark_metrics.json"),
+                "report": str(self.out_dir / "report.md"),
+            },
+            "executables": {
+                "rbdock": probe_version(require_executable("rbdock")),
+                "rbcavity": probe_version(require_executable("rbcavity")),
+                "obabel": probe_version(require_executable("obabel")),
+            },
+            "metrics": metrics,
+        }
+        _write_json(self.out_dir / "manifest.json", manifest)
+        _write_yaml_like(
+            self.out_dir / "config.yaml",
+            {
+                "dataset_dir": str(self.dataset_dir),
+                "strategy": self.config.strategy,
+                "fidelity_levels": self.config.fidelity_levels,
+                "cost_budget_runs": self.config.cost_budget_runs,
+                "promotion_fraction": self.config.promotion_fraction,
+                "min_per_cluster": self.config.min_per_cluster,
+                "max_per_cluster": self.config.max_per_cluster,
+                "outlier_intra_z_threshold": self.config.outlier_intra_z_threshold,
+                "score_component_filter": self.config.score_component_filter,
+                "final_fidelity_only_hits": self.config.final_fidelity_only_hits,
+                "jobs": self.config.jobs,
+                "cpu_fraction": self.config.cpu_fraction,
+                "resume": self.config.resume,
+            },
+        )
+        return {"run_dir": str(self.out_dir), "metrics": metrics}
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Run adaptive rDock benchmark from a prepared dataset directory.")
+    parser.add_argument("--dataset-dir", required=True)
+    parser.add_argument("--strategy", default="multifidelity_adaptive_rdock", choices=["multifidelity_adaptive_rdock", "single_fidelity_adaptive_rdock"])
+    parser.add_argument("--fidelity-levels", default="5,10,15,30,50")
+    parser.add_argument("--cost-budget-runs", type=int, required=True)
+    parser.add_argument("--adaptive-budget-ligands", type=int)
+    parser.add_argument("--promotion-fraction", type=float, default=0.5)
+    parser.add_argument("--min-per-cluster", type=int, default=1)
+    parser.add_argument("--max-per-cluster", type=int, default=50)
+    parser.add_argument("--outlier-intra-z-threshold", type=float, default=3.0)
+    parser.add_argument("--score-component-filter", default="warn")
+    parser.add_argument("--final-fidelity-only-hits", default="true")
+    parser.add_argument("--resume", action="store_true")
+    parser.add_argument("--checkpoint-every", type=int, default=1)
+    parser.add_argument("--jobs", default="auto")
+    parser.add_argument("--cpu-fraction", type=float, default=0.85)
+    parser.add_argument("--out", required=True)
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--plan-only", action="store_true")
+    return parser
+
+
+def run_from_args(args: argparse.Namespace) -> dict[str, Any]:
+    levels = _parse_levels(args.fidelity_levels)
+    dataset_summary = validate_dataset_dir(args.dataset_dir, check_rdock_tools=False)
+    plan = {
+        "dataset_dir": args.dataset_dir,
+        "strategy": args.strategy,
+        "fidelity_levels": levels,
+        "cost_budget_runs": int(args.cost_budget_runs),
+        "adaptive_budget_ligands": args.adaptive_budget_ligands,
+        "promotion_fraction": float(args.promotion_fraction),
+        "min_per_cluster": int(args.min_per_cluster),
+        "max_per_cluster": int(args.max_per_cluster),
+        "outlier_intra_z_threshold": float(args.outlier_intra_z_threshold),
+        "score_component_filter": args.score_component_filter,
+        "final_fidelity_only_hits": str(args.final_fidelity_only_hits).lower() in {"1", "true", "yes", "y"},
+        "jobs": args.jobs,
+        "cpu_fraction": float(args.cpu_fraction),
+        "dataset_summary": dataset_summary,
+    }
+    out_dir = Path(args.out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    if args.dry_run or args.plan_only:
+        _write_json(out_dir / "benchmark_adaptive_plan.json", plan)
+        return plan
+    config = MultiFidelityConfig(
+        strategy=args.strategy,
+        fidelity_levels=levels,
+        cost_budget_runs=int(args.cost_budget_runs),
+        adaptive_budget_ligands=args.adaptive_budget_ligands,
+        promotion_fraction=float(args.promotion_fraction),
+        min_per_cluster=int(args.min_per_cluster),
+        max_per_cluster=int(args.max_per_cluster),
+        outlier_intra_z_threshold=float(args.outlier_intra_z_threshold),
+        score_component_filter=str(args.score_component_filter),
+        final_fidelity_only_hits=str(args.final_fidelity_only_hits).lower() in {"1", "true", "yes", "y"},
+        checkpoint_every=int(args.checkpoint_every),
+        jobs=args.jobs,
+        cpu_fraction=float(args.cpu_fraction),
+        resume=bool(args.resume),
+    )
+    engine = RDockEngine(
+        RDockRunConfig(
+            n_runs=levels[-1],
+            jobs=args.jobs,
+            cpu_fraction=float(args.cpu_fraction),
+            timeout_seconds=3600,
+        )
+    )
+    runner = MultiFidelityAdaptiveRunner(args.dataset_dir, args.out, engine, config)
+    return runner.run_multifidelity()

docking_pipeline/config_io.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .provenance import RDockPipelineError, require_file
+
+
+def load_structured_file(path: str | Path) -> dict[str, Any]:
+    source = require_file(path, "structured config file")
+    text = source.read_text(encoding="utf-8")
+    try:
+        payload = json.loads(text)
+    except json.JSONDecodeError:
+        try:
+            import yaml
+        except Exception as exc:
+            raise RDockPipelineError(
+                f"Could not parse {source} as JSON and PyYAML is unavailable: {exc}"
+            ) from exc
+        payload = yaml.safe_load(text)
+    if not isinstance(payload, dict):
+        raise RDockPipelineError(f"Expected mapping at top level of {source}")
+    return payload
+
+
+def dump_json_like(path: str | Path, payload: dict[str, Any]) -> Path:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    return target

docking_pipeline/dataset.py

@@ -0,0 +1,433 @@
+from __future__ import annotations
+
+import csv
+import json
+import math
+import subprocess
+import shutil
+import urllib.request
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from .config_io import dump_json_like, load_structured_file
+from .provenance import RDockPipelineError, probe_version, require_executable, require_file
+from .rdock import RDockEngine, RDockRunConfig, load_target_config
+from .sdf import split_sdf_file
+
+
+IGNORED_SOLVENT_RESNAMES = {
+    "HOH",
+    "WAT",
+    "DOD",
+    "SOL",
+    "EDO",
+    "GOL",
+    "PEG",
+    "PG4",
+    "PGE",
+    "MPD",
+    "EOH",
+    "IPA",
+    "DMS",
+    "ACT",
+    "ACY",
+    "FMT",
+    "TRS",
+    "MES",
+    "BME",
+}
+IGNORED_BUFFER_RESNAMES = {
+    "SO4",
+    "PO4",
+    "CL",
+    "BR",
+    "IOD",
+    "NO3",
+    "SCN",
+    "IMD",
+    "CIT",
+    "ACE",
+}
+METAL_ELEMENTS = {
+    "LI",
+    "NA",
+    "K",
+    "RB",
+    "CS",
+    "MG",
+    "CA",
+    "SR",
+    "BA",
+    "ZN",
+    "FE",
+    "CO",
+    "NI",
+    "CU",
+    "MN",
+    "CD",
+    "HG",
+    "AG",
+    "AU",
+}
+
+
+def count_sdf_records(path: str | Path) -> int:
+    return len(split_sdf_file(path))
+
+
+def list_known_good_complexes(config_path: str | Path) -> list[dict[str, Any]]:
+    payload = load_structured_file(config_path)
+    complexes = payload.get("complexes")
+    if not isinstance(complexes, list):
+        raise RDockPipelineError(f"`complexes` list missing in {config_path}")
+    return [dict(item) for item in complexes]
+
+
+def _parse_pdb_atom_line(line: str) -> dict[str, Any]:
+    record = line[:6].strip()
+    atom_name = line[12:16].strip()
+    resname = line[17:20].strip().upper()
+    chain = line[21:22].strip()
+    residue_id = line[22:26].strip()
+    try:
+        x = float(line[30:38].strip())
+        y = float(line[38:46].strip())
+        z = float(line[46:54].strip())
+    except ValueError:
+        x = y = z = math.nan
+    element = line[76:78].strip().upper() or "".join(char for char in atom_name if char.isalpha())[:2].upper()
+    return {
+        "record": record,
+        "atom_name": atom_name,
+        "resname": resname,
+        "chain": chain,
+        "residue_id": residue_id,
+        "x": x,
+        "y": y,
+        "z": z,
+        "element": element,
+        "line": line,
+    }
+
+
+def _is_heavy_atom(element: str) -> bool:
+    return bool(element) and element != "H"
+
+
+def _classify_hetero_group(resname: str, elements: set[str], heavy_atom_count: int) -> tuple[bool, str]:
+    if resname in IGNORED_SOLVENT_RESNAMES:
+        return True, "solvent"
+    if resname in IGNORED_BUFFER_RESNAMES:
+        return True, "buffer_or_salt"
+    if elements and elements.issubset(METAL_ELEMENTS):
+        return True, "ion_or_metal"
+    if heavy_atom_count <= 1:
+        return True, "tiny_fragment"
+    return False, ""
+
+
+def list_hetero_ligands(pdb_like: str | Path, min_reference_ligand_atoms: int = 8) -> list[dict[str, Any]]:
+    source = require_file(pdb_like, "PDB/mmCIF structure")
+    groups: dict[tuple[str, str, str], dict[str, Any]] = {}
+    for line in source.read_text(encoding="utf-8", errors="ignore").splitlines():
+        if not line.startswith("HETATM"):
+            continue
+        atom = _parse_pdb_atom_line(line)
+        key = (atom["resname"], atom["chain"], atom["residue_id"])
+        group = groups.setdefault(
+            key,
+            {
+                "resname": atom["resname"],
+                "chain": atom["chain"],
+                "residue_id": atom["residue_id"],
+                "atom_count": 0,
+                "heavy_atom_count": 0,
+                "elements": set(),
+            },
+        )
+        group["atom_count"] += 1
+        if _is_heavy_atom(atom["element"]):
+            group["heavy_atom_count"] += 1
+        if atom["element"]:
+            group["elements"].add(atom["element"])
+    rows: list[dict[str, Any]] = []
+    for _, group in sorted(groups.items()):
+        ignored, reason = _classify_hetero_group(
+            str(group["resname"]),
+            set(group["elements"]),
+            int(group["heavy_atom_count"]),
+        )
+        rows.append(
+            {
+                "resname": str(group["resname"]),
+                "chain": str(group["chain"]),
+                "residue_id": str(group["residue_id"]),
+                "atom_count": int(group["atom_count"]),
+                "heavy_atom_count": int(group["heavy_atom_count"]),
+                "ignored": ignored,
+                "ignored_reason": reason,
+                "candidate_ligand": (not ignored) and int(group["heavy_atom_count"]) >= int(min_reference_ligand_atoms),
+            }
+        )
+    return rows
+
+
+def auto_detect_reference_ligand(
+    pdb_like: str | Path,
+    receptor_chain: str,
+    min_reference_ligand_atoms: int = 8,
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    source = require_file(pdb_like, "PDB/mmCIF structure")
+    hetero = list_hetero_ligands(source, min_reference_ligand_atoms=min_reference_ligand_atoms)
+    receptor_chains = {item.strip() for item in receptor_chain.split(",") if item.strip()}
+    receptor_atoms: list[tuple[float, float, float]] = []
+    ligand_atoms: dict[tuple[str, str, str], list[tuple[float, float, float]]] = {}
+    for line in source.read_text(encoding="utf-8", errors="ignore").splitlines():
+        if not line.startswith(("ATOM", "HETATM")):
+            continue
+        atom = _parse_pdb_atom_line(line)
+        if line.startswith("ATOM") and (not receptor_chains or atom["chain"] in receptor_chains):
+            if not math.isnan(atom["x"]):
+                receptor_atoms.append((atom["x"], atom["y"], atom["z"]))
+        elif line.startswith("HETATM"):
+            key = (atom["resname"], atom["chain"], atom["residue_id"])
+            ligand_atoms.setdefault(key, [])
+            if not math.isnan(atom["x"]):
+                ligand_atoms[key].append((atom["x"], atom["y"], atom["z"]))
+    if not receptor_atoms:
+        raise RDockPipelineError(f"No receptor atoms found in {source} for chain(s) {receptor_chain}")
+
+    def _min_distance(points: list[tuple[float, float, float]]) -> float:
+        best = math.inf
+        for lx, ly, lz in points:
+            for rx, ry, rz in receptor_atoms:
+                dist = math.dist((lx, ly, lz), (rx, ry, rz))
+                if dist < best:
+                    best = dist
+        return best
+
+    candidates: list[dict[str, Any]] = []
+    for row in hetero:
+        key = (str(row["resname"]), str(row["chain"]), str(row["residue_id"]))
+        points = ligand_atoms.get(key, [])
+        if not points:
+            continue
+        min_dist = _min_distance(points)
+        enriched = dict(row)
+        enriched["min_distance_to_receptor"] = min_dist
+        enriched["contact_candidate"] = bool(row["candidate_ligand"]) and min_dist <= 6.0
+        candidates.append(enriched)
+    viable = [row for row in candidates if row["candidate_ligand"]]
+    if not viable:
+        raise RDockPipelineError(
+            f"No suitable reference ligand candidates found in {source}. "
+            f"Available hetero entries: {candidates[:20]}"
+        )
+    viable.sort(
+        key=lambda item: (
+            int(bool(item.get("contact_candidate"))),
+            int(item.get("heavy_atom_count", 0)),
+            int(item.get("atom_count", 0)),
+            -float(item.get("min_distance_to_receptor", math.inf)),
+        ),
+        reverse=True,
+    )
+    return viable[0], candidates
+
+
+def resolve_known_good_defaults(
+    config_path: str | Path,
+    pdb_id: str,
+    receptor_chain: str | None,
+    ligand_resname: str | None,
+    ligand_chain: str | None,
+) -> dict[str, str]:
+    pdb_upper = pdb_id.upper().strip()
+    matches = [item for item in list_known_good_complexes(config_path) if str(item.get("pdb_id", "")).upper() == pdb_upper]
+    if not matches:
+        return {
+            "pdb_id": pdb_upper,
+            "receptor_chain": receptor_chain or "",
+            "reference_ligand_resname": ligand_resname or "",
+            "reference_ligand_chain": ligand_chain or "",
+        }
+    chosen = matches[0]
+    return {
+        "pdb_id": pdb_upper,
+        "receptor_chain": receptor_chain or str(chosen.get("receptor_chain", "")),
+        "reference_ligand_resname": ligand_resname or str(chosen.get("reference_ligand_resname", "")),
+        "reference_ligand_chain": ligand_chain or str(chosen.get("reference_ligand_chain", "")),
+    }
+
+
+def download_pdb_structure(pdb_id: str, out_dir: str | Path, force: bool = False) -> Path:
+    target_dir = Path(out_dir)
+    target_dir.mkdir(parents=True, exist_ok=True)
+    pdb_id = pdb_id.upper().strip()
+    pdb_path = target_dir / f"{pdb_id.lower()}.pdb"
+    if pdb_path.exists() and pdb_path.stat().st_size > 0 and not force:
+        return pdb_path
+    url = f"https://files.rcsb.org/download/{pdb_id}.pdb"
+    try:
+        urllib.request.urlretrieve(url, pdb_path)
+    except Exception as exc:
+        curl = shutil.which("curl")
+        if curl:
+            proc = subprocess.run(
+                [curl, "-fsSL", url, "-o", str(pdb_path)],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            if proc.returncode == 0 and pdb_path.exists() and pdb_path.stat().st_size > 0:
+                return require_file(pdb_path, f"downloaded PDB for {pdb_id}")
+            raise RDockPipelineError(
+                f"Failed to download PDB {pdb_id} from {url}. urllib error: {exc}. "
+                f"curl stderr: {proc.stderr.strip() or '<empty>'}. "
+                f"Check network access or provide a locally cached PDB in {target_dir}."
+            ) from exc
+        raise RDockPipelineError(
+            f"Failed to download PDB {pdb_id} from {url}: {exc}. "
+            "curl is not available for fallback; check network access or pre-stage the PDB file locally."
+        ) from exc
+    return require_file(pdb_path, f"downloaded PDB for {pdb_id}")
+
+
+def extract_receptor_and_reference_ligand(
+    pdb_like: str | Path,
+    receptor_chain: str,
+    ligand_resname: str,
+    ligand_chain: str,
+    out_dir: str | Path,
+    min_reference_ligand_atoms: int = 8,
+) -> tuple[Path, Path, list[dict[str, str]]]:
+    source = require_file(pdb_like, "PDB/mmCIF structure")
+    out_root = Path(out_dir)
+    out_root.mkdir(parents=True, exist_ok=True)
+    receptor = out_root / "target_raw.pdb"
+    ligand_pdb = out_root / "reference_ligand_raw.pdb"
+
+    receptor_lines: list[str] = []
+    ligand_lines: list[str] = []
+    hetero_rows = list_hetero_ligands(source, min_reference_ligand_atoms=min_reference_ligand_atoms)
+    receptor_chains = {item.strip() for item in receptor_chain.split(",") if item.strip()}
+    wanted_resname = ligand_resname.upper().strip()
+    wanted_chain = ligand_chain.strip()
+    wanted_keys = {
+        (str(item["resname"]), str(item["chain"]), str(item["residue_id"]))
+        for item in hetero_rows
+        if str(item["resname"]) == wanted_resname and (not wanted_chain or str(item["chain"]) == wanted_chain)
+    }
+
+    for line in source.read_text(encoding="utf-8", errors="ignore").splitlines():
+        record = line[:6].strip()
+        atom = _parse_pdb_atom_line(line)
+        chain = str(atom["chain"])
+        resname = str(atom["resname"])
+        if record == "ATOM" and (not receptor_chains or chain in receptor_chains):
+            receptor_lines.append(line)
+        if record == "HETATM":
+            key = (resname, chain, str(atom["residue_id"]))
+            if key in wanted_keys:
+                ligand_lines.append(line)
+    if not receptor_lines:
+        raise RDockPipelineError(f"No receptor atoms found in {source} for chain(s) {receptor_chain}")
+    if not ligand_lines:
+        raise RDockPipelineError(
+            f"Reference ligand {wanted_resname} chain {wanted_chain or '*'} not found in {source}. "
+            f"Available hetero ligands: {hetero_rows[:20]}"
+        )
+
+    receptor.write_text("\n".join(receptor_lines + ["END", ""]), encoding="utf-8")
+    ligand_pdb.write_text("\n".join(ligand_lines + ["END", ""]), encoding="utf-8")
+    return receptor, ligand_pdb, hetero_rows
+
+
+def validate_dataset_dir(dataset_dir: str | Path, check_rdock_tools: bool = False) -> dict[str, Any]:
+    root = Path(dataset_dir)
+    manifest_path = root / "dataset_manifest.json"
+    manifest = json.loads(require_file(manifest_path, "dataset manifest").read_text(encoding="utf-8"))
+    required = {
+        "target_mol2": root / "target" / "target.mol2",
+        "reference_ligand_sdf": root / "target" / "reference_ligand.sdf",
+        "all_ligands_sdf": root / "ligands" / "all_ligands.sdf",
+        "invalid_ligands_csv": root / "ligands" / "invalid_ligands.csv",
+        "preparation_report": root / "qc" / "preparation_report.md",
+        "target_config": root / "target" / "rdock_prm" / "target_config.yaml",
+    }
+    for label, path in required.items():
+        require_file(path, label)
+    ligand_count = count_sdf_records(required["all_ligands_sdf"])
+    expected_count = int(manifest.get("ligands_prepared", 0))
+    if expected_count and ligand_count != expected_count:
+        raise RDockPipelineError(
+            f"Ligand count mismatch for {root}: manifest says {expected_count}, SDF contains {ligand_count}"
+        )
+    ref_count = count_sdf_records(required["reference_ligand_sdf"])
+    if ref_count < 1:
+        raise RDockPipelineError(f"Reference ligand SDF is empty in {root}")
+    target_config = load_target_config(required["target_config"])
+    cavity = require_file(target_config.cavity_as, "rDock cavity .as file from dataset")
+    if cavity.stat().st_size <= 0:
+        raise RDockPipelineError(f"Invalid empty cavity file in dataset: {cavity}")
+    ligand_source = str(manifest.get("ligand_source", ""))
+    if ligand_source.startswith("pubchem"):
+        require_file(root / "logs" / "pubchem_diagnostics.json", "PubChem diagnostics log")
+    tools: dict[str, str] = {}
+    if check_rdock_tools:
+        tools = {
+            "rbdock": probe_version(require_executable("rbdock")),
+            "rbcavity": probe_version(require_executable("rbcavity")),
+            "obabel": probe_version(require_executable("obabel")),
+        }
+    return {
+        "dataset_dir": str(root),
+        "manifest": manifest,
+        "ligand_count": ligand_count,
+        "reference_records": ref_count,
+        "target_config": str(required["target_config"]),
+        "executables": tools,
+    }
+
+
+def create_dataset_manifest(
+    dataset_dir: str | Path,
+    payload: dict[str, Any],
+) -> Path:
+    root = Path(dataset_dir)
+    payload = dict(payload)
+    payload["created_at"] = datetime.now(UTC).isoformat()
+    return dump_json_like(root / "dataset_manifest.json", payload)
+
+
+def copy_prepared_target_bundle(target_config_dir: str | Path, dataset_target_dir: str | Path) -> dict[str, str]:
+    src = Path(target_config_dir)
+    dst = Path(dataset_target_dir)
+    dst.mkdir(parents=True, exist_ok=True)
+    copied: dict[str, str] = {}
+    for path in src.iterdir():
+        if path.is_file():
+            shutil.copy2(path, dst / path.name)
+            copied[path.name] = str(dst / path.name)
+    return copied
+
+
+def prepare_dataset_target_with_rdock(
+    receptor_pdb: str | Path,
+    reference_ligand_sdf: str | Path,
+    out_dir: str | Path,
+    jobs: int | str = "auto",
+    cpu_fraction: float = 0.85,
+) -> dict[str, Any]:
+    engine = RDockEngine(RDockRunConfig(jobs=jobs, cpu_fraction=cpu_fraction))
+    target_config = engine.prepare_target(receptor_pdb, reference_ligand_sdf, out_dir)
+    return {
+        "target_config_yaml": str(Path(out_dir) / "target_config.yaml"),
+        "target_config": target_config.__dict__,
+    }
+
+
+def read_ligand_metadata(path: str | Path) -> list[dict[str, str]]:
+    with require_file(path, "ligand metadata CSV").open("r", encoding="utf-8", newline="") as handle:
+        return list(csv.DictReader(handle))

docking_pipeline/metrics.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import math
+import json
+import csv
+from pathlib import Path
+
+
+def roc_auc(scores: list[float], labels: list[int]) -> float:
+    pairs = [(float(s), int(y)) for s, y in zip(scores, labels)]
+    pos = [s for s, y in pairs if y == 1]
+    neg = [s for s, y in pairs if y == 0]
+    if not pos or not neg:
+        return float("nan")
+    wins = 0.0
+    for p in pos:
+        wins += sum(1.0 for n in neg if p < n)
+        wins += 0.5 * sum(1.0 for n in neg if p == n)
+    return float(wins / (len(pos) * len(neg)))
+
+
+def enrichment_factor(scores: list[float], labels: list[int], fraction: float) -> float:
+    pairs = [(float(s), int(y)) for s, y in zip(scores, labels)]
+    n = len(pairs)
+    total_actives = sum(y for _, y in pairs)
+    if n == 0 or total_actives == 0:
+        return float("nan")
+    k = max(1, int(math.ceil(n * fraction)))
+    top = sorted(pairs, key=lambda item: item[0])[:k]
+    hit_rate_top = float(sum(y for _, y in top)) / float(k)
+    hit_rate_all = float(total_actives) / float(n)
+    return float(hit_rate_top / hit_rate_all) if hit_rate_all > 0 else float("nan")
+
+
+def bedroc(scores: list[float], labels: list[int], alpha: float = 20.0) -> float:
+    pairs = sorted([(float(s), int(y)) for s, y in zip(scores, labels)], key=lambda item: item[0])
+    n = len(pairs)
+    n_act = sum(y for _, y in pairs)
+    if n == 0 or n_act == 0 or n_act == n:
+        return float("nan")
+    ranks = [idx + 1 for idx, (_, y) in enumerate(pairs) if y == 1]
+    denom = (1 - math.exp(-alpha)) / (math.exp(alpha / n) - 1)
+    rie = (n / n_act) * sum(math.exp(-alpha * rank / n) for rank in ranks) / denom
+    rie_min = (n / n_act) * sum(math.exp(-alpha * rank / n) for rank in range(n - n_act + 1, n + 1)) / denom
+    rie_max = (n / n_act) * sum(math.exp(-alpha * rank / n) for rank in range(1, n_act + 1)) / denom
+    return float((rie - rie_min) / (rie_max - rie_min))
+
+
+def enrichment_rows(scores: list[float], labels: list[int]) -> list[dict[str, float]]:
+    rows = []
+    for frac in (0.01, 0.05, 0.10, 0.20):
+        rows.append({"fraction": frac, "enrichment_factor": enrichment_factor(scores, labels, frac)})
+    return rows
+
+
+def validation_metrics_from_rows(rows: list[dict[str, object]], score_col: str = "SCORE", label_col: str = "label") -> dict[str, float]:
+    scores = [float(row[score_col]) for row in rows]
+    labels = [int(float(row.get(label_col, 0) or 0)) for row in rows]
+    return {
+        "roc_auc": roc_auc(scores, labels),
+        "ef1": enrichment_factor(scores, labels, 0.01),
+        "ef5": enrichment_factor(scores, labels, 0.05),
+        "ef10": enrichment_factor(scores, labels, 0.10),
+        "ef20": enrichment_factor(scores, labels, 0.20),
+        "bedroc20": bedroc(scores, labels, alpha=20.0),
+    }
+
+
+def write_metrics(rows: list[dict[str, object]], metrics_json: str | Path, enrichment_csv: str | Path) -> dict[str, float]:
+    metrics = validation_metrics_from_rows(rows)
+    Path(metrics_json).parent.mkdir(parents=True, exist_ok=True)
+    Path(metrics_json).write_text(json.dumps(metrics, indent=2), encoding="utf-8")
+    scores = [float(row["SCORE"]) for row in rows]
+    labels = [int(float(row.get("label", 0) or 0)) for row in rows]
+    with Path(enrichment_csv).open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=["fraction", "enrichment_factor"])
+        writer.writeheader()
+        writer.writerows(enrichment_rows(scores, labels))
+    return metrics
+
+
+validation_metrics_from_table = validation_metrics_from_rows
+enrichment_table = enrichment_rows

docking_pipeline/provenance.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+from dataclasses import asdict, dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Sequence
+
+
+class RDockPipelineError(RuntimeError):
+    """Raised for actionable pipeline failures."""
+
+
+def sha256_file(path: str | Path) -> str:
+    source = Path(path)
+    h = hashlib.sha256()
+    with source.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def require_file(path: str | Path, label: str) -> Path:
+    p = Path(path)
+    if not p.exists():
+        raise RDockPipelineError(f"Missing {label}: {p}")
+    if p.is_file() and p.stat().st_size == 0:
+        raise RDockPipelineError(f"Empty {label}: {p}")
+    return p
+
+
+def require_executable(name: str) -> str:
+    resolved = shutil.which(name)
+    if not resolved:
+        raise RDockPipelineError(
+            f"Required executable `{name}` was not found on PATH. Install rDock/OpenBabel "
+            "and ensure RBT_ROOT/RBT_HOME/library paths are configured before running."
+        )
+    return resolved
+
+
+def probe_version(executable: str) -> str:
+    for args in ([executable, "--version"], [executable, "-version"], [executable, "-h"]):
+        try:
+            proc = subprocess.run(args, check=False, capture_output=True, text=True, timeout=10)
+        except Exception:
+            continue
+        text = "\n".join([proc.stdout or "", proc.stderr or ""]).strip()
+        if text:
+            for line in text.splitlines():
+                probe = line.strip()
+                if probe and set(probe) != {"*"}:
+                    return probe[:240]
+            return text.splitlines()[0][:240]
+    return "unavailable"
+
+
+@dataclass
+class CommandRecord:
+    stage: str
+    command: list[str]
+    cwd: str
+    start_time: str
+    end_time: str
+    exit_code: int
+    stdout_log: str
+    stderr_log: str
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+
+class CommandRunner:
+    def __init__(self, command_log: str | Path) -> None:
+        self.command_log = Path(command_log)
+        self.command_log.parent.mkdir(parents=True, exist_ok=True)
+        self.records: list[CommandRecord] = []
+
+    def run(
+        self,
+        stage: str,
+        command: Sequence[str],
+        cwd: str | Path,
+        stdout_log: str | Path,
+        stderr_log: str | Path,
+        timeout: int | None = None,
+        env: dict[str, str] | None = None,
+    ) -> CommandRecord:
+        cwd_path = Path(cwd)
+        stdout_path = Path(stdout_log)
+        stderr_path = Path(stderr_log)
+        stdout_path.parent.mkdir(parents=True, exist_ok=True)
+        stderr_path.parent.mkdir(parents=True, exist_ok=True)
+        start = datetime.now(UTC).isoformat()
+        merged_env = os.environ.copy()
+        if env:
+            merged_env.update(env)
+        try:
+            proc = subprocess.run(
+                list(command),
+                cwd=str(cwd_path),
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                env=merged_env,
+            )
+            stdout = proc.stdout or ""
+            stderr = proc.stderr or ""
+            rc = int(proc.returncode)
+        except subprocess.TimeoutExpired as exc:
+            stdout = exc.stdout if isinstance(exc.stdout, str) else ""
+            stderr = (exc.stderr if isinstance(exc.stderr, str) else "") + f"\nTIMEOUT after {timeout}s"
+            rc = 124
+        end = datetime.now(UTC).isoformat()
+        stdout_path.write_text(stdout, encoding="utf-8")
+        stderr_path.write_text(stderr, encoding="utf-8")
+        rec = CommandRecord(
+            stage=stage,
+            command=list(command),
+            cwd=str(cwd_path),
+            start_time=start,
+            end_time=end,
+            exit_code=rc,
+            stdout_log=str(stdout_path),
+            stderr_log=str(stderr_path),
+        )
+        self.records.append(rec)
+        with self.command_log.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(rec.to_dict(), sort_keys=True) + "\n")
+        return rec
+
+
+def fail_if_bad_command(record: CommandRecord, expected: str) -> None:
+    stdout = Path(record.stdout_log).read_text(encoding="utf-8", errors="ignore") if record.stdout_log else ""
+    stderr = Path(record.stderr_log).read_text(encoding="utf-8", errors="ignore") if record.stderr_log else ""
+    text = f"{stdout}\n{stderr}"
+    error_markers = (
+        "RBT_FILE_READ_ERROR",
+        "RBT_ERROR",
+        "BAD_RECEPTOR_FILE",
+        "Error opening",
+        "Segmentation fault",
+        "Fatal",
+    )
+    if record.exit_code == 0 and not any(marker.lower() in text.lower() for marker in error_markers):
+        return
+    raise RDockPipelineError(
+        f"{expected} failed with exit code {record.exit_code}. Command: {' '.join(record.command)}. "
+        f"See stdout log: {record.stdout_log}; stderr log: {record.stderr_log}. "
+        f"Last diagnostic: {text.strip()[-1200:]}"
+    )

docking_pipeline/rdock.py

@@ -0,0 +1,561 @@
+from __future__ import annotations
+
+import json
+import math
+import os
+import shutil
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import asdict, dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from .provenance import (
+    CommandRecord,
+    CommandRunner,
+    RDockPipelineError,
+    fail_if_bad_command,
+    probe_version,
+    require_executable,
+    require_file,
+    sha256_file,
+)
+from .sdf import best_per_ligand, parse_rdock_sdf_records, records_to_rows, split_sdf_file, write_rows_csv, write_sdf_blocks, write_sdf_records
+
+
+@dataclass
+class TargetConfig:
+    receptor: str
+    reference_ligand: str
+    target_dir: str
+    receptor_mol2: str
+    receptor_prm: str
+    cavity_as: str
+    pocket_center: list[float]
+    pocket_radius: float
+    diagnostics: dict[str, Any]
+
+
+@dataclass
+class RDockRunConfig:
+    n_runs: int = 50
+    jobs: int | str = "auto"
+    cpu_fraction: float = 0.85
+    timeout_seconds: int = 3600
+    rbdock_bin: str = "rbdock"
+    rbcavity_bin: str = "rbcavity"
+    obabel_bin: str = "obabel"
+    sdsort_bin: str = "sdsort"
+    sdfilter_bin: str = "sdfilter"
+    sdreport_bin: str = "sdreport"
+    sdrmsd_bin: str = "sdrmsd"
+    sdsplit_bin: str = "sdsplit"
+    dock_prm: str | None = None
+    rbt_root: str | None = None
+    require_reporting_tools: bool = False
+
+
+@dataclass
+class RunArtifacts:
+    run_dir: str
+    manifest: str
+    config_yaml: str
+    commands_log: str
+    all_poses_sdf: str
+    best_per_ligand_sdf: str
+    scores_long_csv: str
+    best_per_ligand_csv: str
+    report_md: str
+    command_records: list[dict[str, Any]] = field(default_factory=list)
+    best_ligand_poses_sdf: str | None = None
+
+
+def _write_yaml_like(path: Path, payload: dict[str, Any]) -> None:
+    try:
+        import yaml
+
+        text = yaml.safe_dump(payload, sort_keys=False)
+    except Exception:
+        text = json.dumps(payload, indent=2)
+    path.write_text(text, encoding="utf-8")
+
+
+def _coords_from_pdb(path: Path, include_hetatm: bool) -> np.ndarray:
+    coords: list[list[float]] = []
+    for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
+        if not line.startswith(("ATOM", "HETATM")):
+            continue
+        if line.startswith("HETATM") and not include_hetatm:
+            continue
+        try:
+            coords.append([float(line[30:38]), float(line[38:46]), float(line[46:54])])
+        except Exception:
+            continue
+    return coords  # type: ignore[return-value]
+
+
+def _coords_from_mol2(path: Path) -> np.ndarray:
+    coords: list[list[float]] = []
+    in_atoms = False
+    for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
+        if line.startswith("@<TRIPOS>ATOM"):
+            in_atoms = True
+            continue
+        if line.startswith("@<TRIPOS>") and in_atoms:
+            break
+        if not in_atoms:
+            continue
+        parts = line.split()
+        if len(parts) >= 5:
+            try:
+                coords.append([float(parts[2]), float(parts[3]), float(parts[4])])
+            except Exception:
+                continue
+    return coords  # type: ignore[return-value]
+
+
+def _coords_from_sdf(path: Path) -> np.ndarray:
+    first = path.read_text(encoding="utf-8", errors="ignore").split("$$$$", 1)[0]
+    lines = first.splitlines()
+    if len(lines) < 4:
+        return []  # type: ignore[return-value]
+    try:
+        atom_count = int(lines[3][0:3])
+    except Exception:
+        atom_count = 0
+    coords = []
+    for line in lines[4 : 4 + atom_count]:
+        try:
+            coords.append([float(line[0:10]), float(line[10:20]), float(line[20:30])])
+        except Exception:
+            parts = line.split()
+            if len(parts) >= 3:
+                try:
+                    coords.append([float(parts[0]), float(parts[1]), float(parts[2])])
+                except Exception:
+                    continue
+    return coords  # type: ignore[return-value]
+
+
+def _coords_for_structure(path: Path, receptor: bool) -> np.ndarray:
+    suffix = path.suffix.lower()
+    if suffix == ".mol2":
+        return _coords_from_mol2(path)
+    if suffix in {".sdf", ".sd"}:
+        return _coords_from_sdf(path)
+    if suffix in {".pdb", ".ent", ".cif", ".mmcif"}:
+        return _coords_from_pdb(path, include_hetatm=not receptor)
+    raise RDockPipelineError(f"Unsupported structure format for coordinate validation: {path}")
+
+
+def _validate_receptor_ligand_geometry(receptor: Path, ligand: Path) -> tuple[list[float], dict[str, Any]]:
+    receptor_coords = _coords_for_structure(receptor, receptor=True)
+    ligand_coords = _coords_for_structure(ligand, receptor=False)
+    if not receptor_coords:
+        raise RDockPipelineError(f"Missing receptor atoms or coordinates in {receptor}")
+    if not ligand_coords:
+        raise RDockPipelineError(f"Missing ligand coordinates in reference ligand {ligand}")
+    n_lig = len(ligand_coords)
+    center = [sum(coord[i] for coord in ligand_coords) / n_lig for i in range(3)]
+
+    def dist(a: list[float], b: list[float]) -> float:
+        return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2) ** 0.5
+
+    all_dists = [dist(r, l) for r in receptor_coords for l in ligand_coords]
+    min_receptor_ligand_dist = min(all_dists)
+    centroid_to_receptor = min(dist(r, center) for r in receptor_coords)
+    severe_clashes = sum(1 for d in all_dists if d < 1.0)
+    clash_fraction = severe_clashes / float(max(1, len(ligand_coords)))
+    if centroid_to_receptor > 20.0:
+        raise RDockPipelineError(
+            f"Reference ligand centroid is {centroid_to_receptor:.2f} A from the nearest receptor atom; "
+            "check receptor/reference ligand pairing and coordinate frames."
+        )
+    if clash_fraction > 1.0:
+        raise RDockPipelineError(
+            f"Severe receptor-ligand clashes before docking ({severe_clashes} atom pairs < 1.0 A). "
+            "Check protonation, alternate locations, and coordinate consistency."
+        )
+    spread = max(dist(l, center) for l in ligand_coords)
+    return [float(center[0]), float(center[1]), float(center[2])], {
+        "receptor_atom_count": int(len(receptor_coords)),
+        "reference_ligand_atom_count": int(len(ligand_coords)),
+        "reference_ligand_centroid": [float(x) for x in center],
+        "reference_ligand_radius": spread,
+        "min_receptor_ligand_distance": min_receptor_ligand_dist,
+        "reference_centroid_to_nearest_receptor_atom": centroid_to_receptor,
+        "severe_clash_pairs_lt_1A": severe_clashes,
+    }
+
+
+class RDockEngine:
+    def __init__(self, config: RDockRunConfig | None = None) -> None:
+        self.config = config or RDockRunConfig()
+
+    def _env(self) -> dict[str, str]:
+        env: dict[str, str] = {}
+        if self.config.rbt_root:
+            env["RBT_ROOT"] = self.config.rbt_root
+        elif os.environ.get("RBT_ROOT"):
+            env["RBT_ROOT"] = str(os.environ["RBT_ROOT"])
+        else:
+            for candidate in (Path("/opt/homebrew/opt/rdock/share"), Path("/usr/local/opt/rdock/share")):
+                if (candidate / "data" / "RbtElements.dat").exists():
+                    env["RBT_ROOT"] = str(candidate)
+                    break
+            if "RBT_ROOT" not in env:
+                cellar = Path("/opt/homebrew/Cellar/rdock")
+                if cellar.exists():
+                    for candidate in sorted(cellar.glob("*/share"), reverse=True):
+                        if (candidate / "data" / "RbtElements.dat").exists():
+                            env["RBT_ROOT"] = str(candidate)
+                            break
+        return env
+
+    def _dock_prm(self) -> Path:
+        if self.config.dock_prm:
+            return require_file(self.config.dock_prm, "rDock protocol dock.prm")
+        rbt_root = self.config.rbt_root or os.environ.get("RBT_ROOT")
+        candidates = []
+        if rbt_root:
+            candidates.append(Path(rbt_root) / "data" / "scripts" / "dock.prm")
+            candidates.append(Path(rbt_root) / "data" / "dock.prm")
+        candidates.extend(
+            [
+                Path("/opt/homebrew/opt/rdock/share/data/scripts/dock.prm"),
+                Path("/usr/local/opt/rdock/share/data/scripts/dock.prm"),
+            ]
+        )
+        cellar = Path("/opt/homebrew/Cellar/rdock")
+        if cellar.exists():
+            candidates.extend(sorted(cellar.glob("*/share/data/scripts/dock.prm"), reverse=True))
+        candidates.append(Path("dock.prm"))
+        for candidate in candidates:
+            if candidate.exists() and candidate.stat().st_size > 0:
+                return candidate.resolve()
+        raise RDockPipelineError(
+            "Could not locate rDock dock.prm. Pass --dock-prm or set RBT_ROOT so "
+            "$RBT_ROOT/data/scripts/dock.prm exists."
+        )
+
+    def check_required_tools(self, validation: bool = False) -> dict[str, str]:
+        needed = {
+            "rbdock": self.config.rbdock_bin,
+            "rbcavity": self.config.rbcavity_bin,
+            "obabel": self.config.obabel_bin,
+        }
+        if validation or self.config.require_reporting_tools:
+            needed.update(
+                {
+                    "sdsort": self.config.sdsort_bin,
+                    "sdfilter": self.config.sdfilter_bin,
+                    "sdreport": self.config.sdreport_bin,
+                    "sdrmsd": self.config.sdrmsd_bin,
+                }
+            )
+        return {key: require_executable(bin_name) for key, bin_name in needed.items()}
+
+    def prepare_target(self, receptor: str | Path, reference_ligand: str | Path, out_dir: str | Path) -> TargetConfig:
+        tools = self.check_required_tools(validation=False)
+        receptor_path = require_file(receptor, "receptor structure")
+        ref_path = require_file(reference_ligand, "reference ligand")
+        out = Path(out_dir)
+        out.mkdir(parents=True, exist_ok=True)
+        command_log = out / "commands.log"
+        runner = CommandRunner(command_log)
+
+        receptor_copy = out / receptor_path.name
+        reference_copy = out / ref_path.name
+        if receptor_path.resolve() != receptor_copy.resolve():
+            shutil.copy2(receptor_path, receptor_copy)
+        if ref_path.resolve() != reference_copy.resolve():
+            shutil.copy2(ref_path, reference_copy)
+
+        center, diagnostics = _validate_receptor_ligand_geometry(receptor_copy, reference_copy)
+        receptor_mol2 = out / "receptor.mol2"
+        if receptor_copy.suffix.lower() == ".mol2":
+            shutil.copy2(receptor_copy, receptor_mol2)
+        else:
+            rec = runner.run(
+                "prepare_receptor_obabel",
+                [tools["obabel"], str(receptor_copy.resolve()), "-O", str(receptor_mol2.resolve())],
+                cwd=out,
+                stdout_log=out / "prepare_receptor_obabel.stdout.log",
+                stderr_log=out / "prepare_receptor_obabel.stderr.log",
+                timeout=300,
+                env=self._env(),
+            )
+            fail_if_bad_command(rec, "OpenBabel receptor conversion")
+        require_file(receptor_mol2, "prepared receptor MOL2")
+
+        prm = out / "receptor.prm"
+        prm.write_text(
+            "\n".join(
+                [
+                    "RBT_PARAMETER_FILE_V1.00",
+                    "TITLE rdock_receptor_reference_ligand",
+                    f"RECEPTOR_FILE {receptor_mol2.resolve()}",
+                    "",
+                    "SECTION MAPPER",
+                    "    SITE_MAPPER RbtLigandSiteMapper",
+                    f"    REF_MOL {reference_copy.resolve()}",
+                    "    RADIUS 6.0",
+                    "    SMALL_SPHERE 1.5",
+                    "END_SECTION",
+                    "",
+                    "SECTION CAVITY",
+                    "    SCORING_FUNCTION RbtCavityGridSF",
+                    "END_SECTION",
+                    "",
+                ]
+            ),
+            encoding="utf-8",
+        )
+
+        rec = runner.run(
+            "rbcavity",
+            [tools["rbcavity"], "-r", prm.name, "-was"],
+            cwd=out,
+            stdout_log=out / "rbcavity.stdout.log",
+            stderr_log=out / "rbcavity.stderr.log",
+            timeout=self.config.timeout_seconds,
+            env=self._env(),
+        )
+        fail_if_bad_command(rec, "rbcavity cavity generation")
+        cavity = out / f"{prm.stem}.as"
+        require_file(cavity, "rDock cavity .as file")
+        if cavity.stat().st_size < 16:
+            raise RDockPipelineError(f"rbcavity produced an invalid tiny cavity file: {cavity}")
+
+        target_config = TargetConfig(
+            receptor=str(receptor_copy),
+            reference_ligand=str(reference_copy),
+            target_dir=str(out),
+            receptor_mol2=str(receptor_mol2),
+            receptor_prm=str(prm),
+            cavity_as=str(cavity),
+            pocket_center=center,
+            pocket_radius=float(max(6.0, diagnostics["reference_ligand_radius"] + 2.0)),
+            diagnostics=diagnostics,
+        )
+        _write_yaml_like(out / "target_config.yaml", asdict(target_config))
+        return target_config
+
+    def _resolve_jobs(self, requested: int | str | None = None) -> int:
+        value = self.config.jobs if requested is None else requested
+        if isinstance(value, str) and value.lower() == "auto":
+            cpus = os.cpu_count() or 1
+            reserve = 1 if cpus <= 4 else 2
+            return max(1, min(cpus - reserve, int(math.floor(cpus * self.config.cpu_fraction))))
+        return max(1, int(value))
+
+    def _split_input_sdf(self, ligands_sdf: Path, split_dir: Path, jobs: int) -> list[Path]:
+        blocks = split_sdf_file(ligands_sdf)
+        if jobs <= 1 or len(blocks) <= 1:
+            target = split_dir / "chunk_000.sdf"
+            write_sdf_blocks(blocks, target)
+            return [target]
+        chunks: list[list[str]] = [[] for _ in range(min(jobs, len(blocks)))]
+        for idx, block in enumerate(blocks):
+            chunks[idx % len(chunks)].append(block)
+        paths = []
+        for idx, chunk in enumerate(chunks):
+            path = split_dir / f"chunk_{idx:03d}.sdf"
+            write_sdf_blocks(chunk, path)
+            paths.append(path)
+        return paths
+
+    def dock_sdf(
+        self,
+        target_config: TargetConfig,
+        ligands_sdf: str | Path,
+        run_dir: str | Path,
+        n_runs: int | None = None,
+        jobs: int | str | None = None,
+        run_id: str | None = None,
+        validation_labels_csv: str | Path | None = None,
+        resume: bool = False,
+    ) -> RunArtifacts:
+        self.check_required_tools(validation=False)
+        ligands = require_file(ligands_sdf, "ligand SDF")
+        dock_prm = self._dock_prm()
+        run_root = Path(run_dir)
+        run_root.mkdir(parents=True, exist_ok=True)
+        for name in ("target", "ligands", "rdock", "poses", "tables", "metrics"):
+            (run_root / name).mkdir(parents=True, exist_ok=True)
+        commands_log = run_root / "commands.log"
+        runner = CommandRunner(commands_log)
+
+        target_dir = run_root / "target"
+        for src in (target_config.receptor, target_config.reference_ligand, target_config.receptor_mol2, target_config.receptor_prm, target_config.cavity_as):
+            p = Path(src)
+            if p.exists():
+                shutil.copy2(p, target_dir / p.name)
+        lig_copy = run_root / "ligands" / ligands.name
+        if ligands.resolve() != lig_copy.resolve():
+            shutil.copy2(ligands, lig_copy)
+        shutil.copy2(dock_prm, run_root / "rdock" / "dock.prm")
+
+        resolved_jobs = self._resolve_jobs(jobs)
+        actual_n_runs = int(n_runs if n_runs is not None else self.config.n_runs)
+        chunks = self._split_input_sdf(lig_copy, run_root / "rdock" / "chunks", resolved_jobs)
+        rbdock = require_executable(self.config.rbdock_bin)
+        prm = Path(target_config.receptor_prm).resolve()
+        out_files: dict[int, Path] = {}
+
+        def _run_chunk(idx: int, chunk: Path) -> tuple[int, CommandRecord, Path]:
+            out_prefix = run_root / "rdock" / f"chunk_{idx:03d}_out"
+            out_sd = out_prefix.with_suffix(".sd")
+            if resume and out_sd.exists() and out_sd.stat().st_size > 0:
+                rec = CommandRecord(
+                    stage=f"rbdock_chunk_{idx:03d}_resume",
+                    command=[rbdock, "-r", str(prm), "-p", str(dock_prm.resolve()), "-n", str(actual_n_runs), "-i", str(chunk.resolve()), "-o", str(out_prefix.resolve())],
+                    cwd=str(run_root / "rdock"),
+                    start_time=datetime.now(UTC).isoformat(),
+                    end_time=datetime.now(UTC).isoformat(),
+                    exit_code=0,
+                    stdout_log=str(run_root / "rdock" / f"chunk_{idx:03d}.stdout.log"),
+                    stderr_log=str(run_root / "rdock" / f"chunk_{idx:03d}.stderr.log"),
+                )
+                return idx, rec, out_sd
+            rec = runner.run(
+                f"rbdock_chunk_{idx:03d}",
+                [
+                    rbdock,
+                    "-r",
+                    str(prm),
+                    "-p",
+                    str(dock_prm.resolve()),
+                    "-n",
+                    str(actual_n_runs),
+                    "-i",
+                    str(chunk.resolve()),
+                    "-o",
+                    str(out_prefix.resolve()),
+                ],
+                cwd=run_root / "rdock",
+                stdout_log=run_root / "rdock" / f"chunk_{idx:03d}.stdout.log",
+                stderr_log=run_root / "rdock" / f"chunk_{idx:03d}.stderr.log",
+                timeout=self.config.timeout_seconds,
+                env=self._env(),
+            )
+            return idx, rec, out_sd
+
+        with ThreadPoolExecutor(max_workers=min(resolved_jobs, len(chunks))) as pool:
+            futures = [pool.submit(_run_chunk, idx, chunk) for idx, chunk in enumerate(chunks)]
+            for fut in as_completed(futures):
+                idx, rec, out_sd = fut.result()
+                fail_if_bad_command(rec, f"rbdock chunk {idx}")
+                require_file(out_sd, f"rDock output SDF for chunk {idx}")
+                out_files[idx] = out_sd
+
+        all_blocks: list[str] = []
+        for idx in sorted(out_files):
+            all_blocks.extend(split_sdf_file(out_files[idx]))
+        all_poses = run_root / "poses" / "all_poses.sdf"
+        write_sdf_blocks(all_blocks, all_poses)
+        records = parse_rdock_sdf_records(all_poses, require_score=True)
+        best = best_per_ligand(records)
+        best_sdf = write_sdf_records(best, run_root / "poses" / "best_per_ligand.sdf")
+        best_ligand_poses_sdf: str | None = None
+        if best:
+            top_ligand_id = best[0].ligand_id
+            best_ligand_records = [rec for rec in records if rec.ligand_id == top_ligand_id]
+            best_ligand_path = run_root / "poses" / f"best_ligand_{actual_n_runs}.sdf"
+            write_sdf_records(best_ligand_records, best_ligand_path)
+            best_ligand_poses_sdf = str(best_ligand_path)
+        scores_long = write_rows_csv(records_to_rows(records), run_root / "tables" / "scores_long.csv")
+        best_csv = write_rows_csv(records_to_rows(best), run_root / "tables" / "best_per_ligand.csv")
+
+        labels_map: dict[str, int] = {}
+        if validation_labels_csv:
+            import pandas as pd
+
+            label_df = pd.read_csv(validation_labels_csv)
+            labels_map = dict(zip(label_df["ligand_id"].astype(str), label_df["label"].astype(int)))
+            best_rows = records_to_rows(best)
+            for row in best_rows:
+                row["label"] = labels_map.get(str(row["ligand_id"]), 0)
+            best_csv = write_rows_csv(best_rows, best_csv)
+
+        manifest_path = run_root / "manifest.json"
+        config_yaml = run_root / "config.yaml"
+        report_md = run_root / "report.md"
+        now = datetime.now(UTC).isoformat()
+        file_inputs = {
+            "ligands_sdf": str(lig_copy),
+            "dock_prm": str(run_root / "rdock" / "dock.prm"),
+            "receptor_prm": str(target_config.receptor_prm),
+            "cavity_as": str(target_config.cavity_as),
+        }
+        manifest = {
+            "run_id": run_id or run_root.name,
+            "created_at": now,
+            "engine": "real-rdock",
+            "n_runs": actual_n_runs,
+            "jobs": resolved_jobs,
+            "input_hashes": {k: sha256_file(v) for k, v in file_inputs.items() if Path(v).exists()},
+            "rdock_versions": {
+                "rbdock": probe_version(rbdock),
+                "rbcavity": probe_version(require_executable(self.config.rbcavity_bin)),
+            },
+            "target_config": asdict(target_config),
+            "commands": [r.to_dict() for r in runner.records],
+            "artifacts": {
+                "all_poses_sdf": str(all_poses),
+                "best_per_ligand_sdf": str(best_sdf),
+                "best_ligand_poses_sdf": best_ligand_poses_sdf,
+                "scores_long_csv": str(scores_long),
+                "best_per_ligand_csv": str(best_csv),
+                "commands_log": str(commands_log),
+            },
+            "pose_count": len(records),
+            "docked_ligand_count": len(best),
+        }
+        manifest_path.write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+        _write_yaml_like(config_yaml, {"rdock": asdict(self.config), "run": {"n_runs": actual_n_runs, "jobs": resolved_jobs}})
+        report_md.write_text(
+            "\n".join(
+                [
+                    "# rDock Run Report",
+                    "",
+                    f"- Engine: `real-rdock`",
+                    f"- Run ID: `{manifest['run_id']}`",
+                    f"- n_runs per ligand: `{actual_n_runs}`",
+                    f"- local jobs: `{resolved_jobs}`",
+                    f"- poses parsed: `{len(records)}`",
+                    f"- docked ligands: `{len(best)}`",
+                    f"- all poses: `{all_poses}`",
+                    f"- best per ligand: `{best_sdf}`",
+                    f"- best ligand all poses: `{best_ligand_poses_sdf or ''}`",
+                    f"- command log: `{commands_log}`",
+                    "",
+                    "No surrogate or undocked ligand is reported as a real rDock hit; hit tables are generated only from parsed rDock SDF records with native SCORE fields.",
+                ]
+            ),
+            encoding="utf-8",
+        )
+        return RunArtifacts(
+            run_dir=str(run_root),
+            manifest=str(manifest_path),
+            config_yaml=str(config_yaml),
+            commands_log=str(commands_log),
+            all_poses_sdf=str(all_poses),
+            best_per_ligand_sdf=str(best_sdf),
+            scores_long_csv=str(scores_long),
+            best_per_ligand_csv=str(best_csv),
+            report_md=str(report_md),
+            command_records=[r.to_dict() for r in runner.records],
+            best_ligand_poses_sdf=best_ligand_poses_sdf,
+        )
+
+
+def load_target_config(path: str | Path) -> TargetConfig:
+    source = require_file(path, "target config")
+    try:
+        import yaml
+
+        data = yaml.safe_load(source.read_text(encoding="utf-8"))
+    except Exception:
+        data = json.loads(source.read_text(encoding="utf-8"))
+    return TargetConfig(**data)

docking_pipeline/reports/__init__.py

@@ -0,0 +1 @@
+"""Report and plotting helpers for strict rDock runs."""

docking_pipeline/reports/plots.py

@@ -0,0 +1,644 @@
+from __future__ import annotations
+
+import csv
+import json
+import math
+import struct
+import zlib
+from pathlib import Path
+from typing import Iterable
+
+
+def _read_rows(path: str | Path) -> list[dict[str, str]]:
+    with Path(path).open("r", encoding="utf-8", newline="") as handle:
+        return list(csv.DictReader(handle))
+
+
+def _floats(rows: Iterable[dict[str, object]], key: str) -> list[float]:
+    out: list[float] = []
+    for row in rows:
+        try:
+            out.append(float(row[key]))  # type: ignore[index]
+        except Exception:
+            continue
+    return out
+
+
+def _boolish(value: object) -> bool:
+    return str(value).strip().lower() in {"1", "true", "yes", "y"}
+
+
+def _float_or_zero(value: object) -> float:
+    try:
+        return float(value)
+    except Exception:
+        return 0.0
+
+
+def _plot_or_skip(plot_dir: Path, name: str, fn) -> str | None:  # type: ignore[no-untyped-def]
+    try:
+        import matplotlib
+
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+    except Exception as exc:
+        (plot_dir / "skipped_plots.json").write_text(
+            json.dumps({"reason": f"matplotlib unavailable: {exc}"}, indent=2),
+            encoding="utf-8",
+        )
+        return None
+    path = plot_dir / name
+    fig = fn(plt)
+    fig.tight_layout()
+    fig.savefig(path, dpi=160)
+    plt.close(fig)
+    return str(path)
+
+
+def _write_png(path: Path, width: int, height: int, pixels: bytearray) -> str:
+    def chunk(tag: bytes, data: bytes) -> bytes:
+        return struct.pack(">I", len(data)) + tag + data + struct.pack(">I", zlib.crc32(tag + data) & 0xFFFFFFFF)
+
+    raw = b"".join(b"\x00" + pixels[y * width * 3 : (y + 1) * width * 3] for y in range(height))
+    png = (
+        b"\x89PNG\r\n\x1a\n"
+        + chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0))
+        + chunk(b"IDAT", zlib.compress(raw, 9))
+        + chunk(b"IEND", b"")
+    )
+    path.write_bytes(png)
+    return str(path)
+
+
+def _simple_plot(path: Path, values: list[float], kind: str = "hist") -> str:
+    width, height = 800, 480
+    pix = bytearray([255] * width * height * 3)
+
+    def setpx(x: int, y: int, color: tuple[int, int, int]) -> None:
+        if 0 <= x < width and 0 <= y < height:
+            i = (y * width + x) * 3
+            pix[i : i + 3] = bytes(color)
+
+    def line(x0: int, y0: int, x1: int, y1: int, color: tuple[int, int, int]) -> None:
+        dx, dy = abs(x1 - x0), -abs(y1 - y0)
+        sx = 1 if x0 < x1 else -1
+        sy = 1 if y0 < y1 else -1
+        err = dx + dy
+        while True:
+            setpx(x0, y0, color)
+            if x0 == x1 and y0 == y1:
+                break
+            e2 = 2 * err
+            if e2 >= dy:
+                err += dy
+                x0 += sx
+            if e2 <= dx:
+                err += dx
+                y0 += sy
+
+    def rect(x0: int, y0: int, x1: int, y1: int, color: tuple[int, int, int]) -> None:
+        for y in range(max(0, y0), min(height, y1)):
+            for x in range(max(0, x0), min(width, x1)):
+                setpx(x, y, color)
+
+    left, top, right, bottom = 70, 40, 760, 420
+    line(left, bottom, right, bottom, (20, 20, 20))
+    line(left, top, left, bottom, (20, 20, 20))
+    vals = [v for v in values if math.isfinite(v)]
+    if not vals:
+        return _write_png(path, width, height, pix)
+    if kind == "bar":
+        ordered = vals[:20]
+        mn = min(0.0, min(ordered))
+        mx = max(0.0, max(ordered))
+        span = mx - mn or 1.0
+        bw = max(2, int((right - left) / max(1, len(ordered))))
+        for i, v in enumerate(ordered):
+            x0 = left + i * bw + 2
+            x1 = left + (i + 1) * bw - 2
+            y = int(bottom - ((v - mn) / span) * (bottom - top))
+            y0, y1 = sorted([bottom, y])
+            rect(x0, y0, x1, y1, (75, 125, 170))
+    else:
+        bins = min(30, max(5, len(vals) // 3))
+        mn, mx = min(vals), max(vals)
+        span = mx - mn or 1.0
+        counts = [0] * bins
+        for v in vals:
+            idx = min(bins - 1, int(((v - mn) / span) * bins))
+            counts[idx] += 1
+        maxc = max(counts) or 1
+        bw = int((right - left) / bins)
+        for i, c in enumerate(counts):
+            x0 = left + i * bw + 1
+            x1 = left + (i + 1) * bw - 1
+            y0 = int(bottom - (c / maxc) * (bottom - top))
+            rect(x0, y0, x1, bottom, (75, 125, 170))
+    return _write_png(path, width, height, pix)
+
+
+def plot_score_outputs(best_csv: str | Path, plot_dir: str | Path, title_prefix: str = "rDock") -> list[str]:
+    pdir = Path(plot_dir)
+    pdir.mkdir(parents=True, exist_ok=True)
+    rows = _read_rows(best_csv)
+    scores = _floats(rows, "SCORE")
+    paths: list[str] = []
+    if not scores:
+        return paths
+
+    def hist(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(7, 4))
+        ax.hist(scores, bins=min(30, max(5, len(scores) // 5)), color="#3b6ea8", edgecolor="white")
+        ax.set_title(f"{title_prefix} SCORE distribution")
+        ax.set_xlabel("SCORE")
+        ax.set_ylabel("Count")
+        return fig
+
+    def topbar(plt):  # type: ignore[no-untyped-def]
+        ordered = sorted(rows, key=lambda r: float(r.get("SCORE", "inf")))[:20]
+        labels = [str(r.get("ligand_id", "")) for r in ordered]
+        vals = [float(r.get("SCORE", "nan")) for r in ordered]
+        fig, ax = plt.subplots(figsize=(9, 4))
+        ax.bar(range(len(vals)), vals, color="#7a9d54")
+        ax.set_title(f"{title_prefix} top SCOREs")
+        ax.set_xlabel("Ligand rank")
+        ax.set_ylabel("SCORE")
+        ax.set_xticks(range(len(vals)))
+        ax.set_xticklabels(labels, rotation=60, ha="right", fontsize=8)
+        return fig
+
+    for name, fn in (("score_distribution.png", hist), ("top_scores.png", topbar)):
+        if path := _plot_or_skip(pdir, name, fn):
+            paths.append(path)
+        else:
+            paths.append(_simple_plot(pdir / name, scores if "distribution" in name else sorted(scores)[:20], "hist" if "distribution" in name else "bar"))
+    return paths
+
+
+def plot_astex_outputs(summary_csv: str | Path, plot_dir: str | Path) -> list[str]:
+    pdir = Path(plot_dir)
+    pdir.mkdir(parents=True, exist_ok=True)
+    rows = _read_rows(summary_csv)
+    top1 = _floats(rows, "top1_rmsd")
+    best = _floats(rows, "best_of_n_rmsd")
+    scores = _floats(rows, "top1_SCORE")
+    paths: list[str] = []
+    if not top1 and not best:
+        return paths
+
+    def hist(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(7, 4))
+        if top1:
+            ax.hist(top1, alpha=0.65, label="top1", bins=20)
+        if best:
+            ax.hist(best, alpha=0.65, label="best-of-n", bins=20)
+        ax.axvline(2.0, color="black", linestyle="--", linewidth=1)
+        ax.set_xlabel("RMSD (A)")
+        ax.set_ylabel("Systems")
+        ax.legend()
+        return fig
+
+    def scatter(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(5, 5))
+        ax.scatter(top1[: len(best)], best[: len(top1)], color="#3b6ea8")
+        ax.axhline(2.0, color="black", linestyle="--", linewidth=1)
+        ax.axvline(2.0, color="black", linestyle="--", linewidth=1)
+        ax.set_xlabel("Top1 RMSD (A)")
+        ax.set_ylabel("Best-of-n RMSD (A)")
+        return fig
+
+    def success_bar(plt):  # type: ignore[no-untyped-def]
+        top1_success = sum(1 for row in rows if _boolish(row.get("success_top1_rmsd_le_2A")))
+        best_success = sum(1 for row in rows if _boolish(row.get("success_best_rmsd_le_2A")))
+        total = max(1, len([r for r in rows if r.get("status") == "success"]))
+        fig, ax = plt.subplots(figsize=(5, 4))
+        ax.bar(["top1 <= 2A", "best <= 2A"], [top1_success / total, best_success / total], color=["#3b6ea8", "#7a9d54"])
+        ax.set_ylim(0, 1)
+        ax.set_ylabel("Successful fraction")
+        return fig
+
+    def score_vs_rmsd(plt):  # type: ignore[no-untyped-def]
+        n = min(len(scores), len(top1))
+        fig, ax = plt.subplots(figsize=(6, 4))
+        ax.scatter(scores[:n], top1[:n], color="#7a4f9d")
+        ax.axhline(2.0, color="black", linestyle="--", linewidth=1)
+        ax.set_xlabel("Top pose SCORE")
+        ax.set_ylabel("Top1 RMSD (A)")
+        return fig
+
+    plot_specs = [("rmsd_distribution.png", hist), ("top1_vs_best_rmsd.png", scatter), ("success_rmsd_le_2A.png", success_bar)]
+    if scores and top1:
+        plot_specs.append(("score_vs_rmsd.png", score_vs_rmsd))
+    for name, fn in plot_specs:
+        if path := _plot_or_skip(pdir, name, fn):
+            paths.append(path)
+        else:
+            values = scores if name == "score_vs_rmsd.png" else (top1 or []) + (best or [])
+            paths.append(_simple_plot(pdir / name, values, "hist"))
+    return paths
+
+
+def plot_dud_outputs(best_csv: str | Path, enrichment_csv: str | Path, plot_dir: str | Path) -> list[str]:
+    pdir = Path(plot_dir)
+    pdir.mkdir(parents=True, exist_ok=True)
+    rows = _read_rows(best_csv)
+    scores = _floats(rows, "SCORE")
+    labels = []
+    for row in rows:
+        try:
+            labels.append(int(float(row.get("label", 0))))
+        except Exception:
+            labels.append(0)
+    paths: list[str] = []
+    if not scores:
+        return paths
+
+    ordered = sorted(zip(scores, labels), key=lambda x: x[0])
+    total_actives = max(1, sum(labels))
+    x = [(i + 1) / len(ordered) for i in range(len(ordered))]
+    y = []
+    seen = 0
+    for _, label in ordered:
+        seen += int(label)
+        y.append(seen / total_actives)
+    total_decoys = max(1, len(labels) - sum(labels))
+    roc_x: list[float] = []
+    roc_y: list[float] = []
+    tp = 0
+    fp = 0
+    for _, label in ordered:
+        if int(label) == 1:
+            tp += 1
+        else:
+            fp += 1
+        roc_x.append(fp / total_decoys)
+        roc_y.append(tp / total_actives)
+    ef_rows = _read_rows(enrichment_csv) if Path(enrichment_csv).exists() else []
+
+    def cumulative(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(7, 4))
+        ax.plot(x, y, color="#3b6ea8")
+        ax.set_xlabel("Ranked fraction")
+        ax.set_ylabel("Cumulative active recovery")
+        return fig
+
+    def score_by_label(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(7, 4))
+        active = [s for s, l in zip(scores, labels) if l == 1]
+        decoy = [s for s, l in zip(scores, labels) if l == 0]
+        if active:
+            ax.hist(active, alpha=0.6, label="actives", bins=20)
+        if decoy:
+            ax.hist(decoy, alpha=0.6, label="decoys", bins=20)
+        ax.set_xlabel("SCORE")
+        ax.set_ylabel("Ligands")
+        ax.legend()
+        return fig
+
+    def roc_curve(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(5, 5))
+        ax.plot([0, *roc_x], [0, *roc_y], color="#3b6ea8")
+        ax.plot([0, 1], [0, 1], color="gray", linestyle="--", linewidth=1)
+        ax.set_xlabel("False positive rate")
+        ax.set_ylabel("True positive rate")
+        return fig
+
+    def semilog_roc(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        xs = [max(0.0005, v) for v in roc_x]
+        ax.plot(xs, roc_y, color="#3b6ea8")
+        ax.set_xscale("log")
+        ax.set_xlabel("False positive rate")
+        ax.set_ylabel("True positive rate")
+        return fig
+
+    def ef_bar(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        labels_ef = [str(row.get("fraction", "")) for row in ef_rows]
+        vals = _floats(ef_rows, "enrichment_factor")
+        ax.bar(labels_ef, vals, color="#7a9d54")
+        ax.set_xlabel("Ranked fraction")
+        ax.set_ylabel("Enrichment factor")
+        return fig
+
+    plot_specs = [
+        ("roc_curve.png", roc_curve),
+        ("semilog_roc.png", semilog_roc),
+        ("enrichment_factors.png", ef_bar),
+        ("cumulative_actives.png", cumulative),
+        ("score_distribution_by_label.png", score_by_label),
+    ]
+    for name, fn in plot_specs:
+        if path := _plot_or_skip(pdir, name, fn):
+            paths.append(path)
+        else:
+            paths.append(_simple_plot(pdir / name, y if "cumulative" in name else scores, "bar" if "cumulative" in name else "hist"))
+    return paths
+
+
+def plot_adaptive_benchmark_outputs(
+    full_csv: str | Path,
+    adaptive_csv: str | Path,
+    random_csv: str | Path,
+    metrics_json: str | Path,
+    plot_dir: str | Path,
+) -> list[str]:
+    pdir = Path(plot_dir)
+    pdir.mkdir(parents=True, exist_ok=True)
+    full_rows = _read_rows(full_csv)
+    adaptive_rows = _read_rows(adaptive_csv)
+    random_rows = _read_rows(random_csv)
+    metrics = json.loads(Path(metrics_json).read_text(encoding="utf-8")) if Path(metrics_json).exists() else {}
+    full_scores = _floats(full_rows, "SCORE")
+    adaptive_scores = _floats(adaptive_rows, "SCORE")
+    random_scores = _floats(random_rows, "SCORE")
+    paths: list[str] = []
+    if not full_scores:
+        return paths
+
+    def cumulative_best(rows: list[dict[str, str]]) -> list[float]:
+        vals = _floats(rows, "SCORE")
+        best: list[float] = []
+        current = float("inf")
+        for value in vals:
+            current = min(current, value)
+            best.append(current)
+        return best
+
+    def cumulative_plot(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(7, 4))
+        full_curve = cumulative_best(full_rows)
+        adaptive_curve = cumulative_best(adaptive_rows)
+        random_curve = cumulative_best(random_rows)
+        if full_curve:
+            ax.plot(range(1, len(full_curve) + 1), full_curve, label="full")
+        if adaptive_curve:
+            ax.plot(range(1, len(adaptive_curve) + 1), adaptive_curve, label="adaptive")
+        if random_curve:
+            ax.plot(range(1, len(random_curve) + 1), random_curve, label="random")
+        ax.set_xlabel("Docked ligand count")
+        ax.set_ylabel("Best SCORE so far")
+        ax.legend()
+        return fig
+
+    def percentile_bar(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        labels = ["adaptive", "random", "full"]
+        vals = [
+            float(metrics.get("adaptive_best_percentile_of_full", 0.0) or 0.0),
+            float(metrics.get("random_best_percentile_of_full", 0.0) or 0.0),
+            float(metrics.get("full_best_percentile_of_full", 100.0) or 100.0),
+        ]
+        ax.bar(labels, vals, color=["#3b6ea8", "#bf7f2f", "#7a9d54"])
+        ax.set_ylim(0, 100)
+        ax.set_ylabel("Percentile in full ranking")
+        return fig
+
+    def runtime_bar(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        labels = ["full docking", "adaptive docking", "random docking", "adaptive model"]
+        vals = [
+            float(metrics.get("full_docking_seconds", 0.0) or 0.0),
+            float(metrics.get("adaptive_docking_seconds", 0.0) or 0.0),
+            float(metrics.get("random_docking_seconds", 0.0) or 0.0),
+            float(metrics.get("adaptive_model_seconds", 0.0) or 0.0),
+        ]
+        ax.bar(labels, vals, color=["#7a9d54", "#3b6ea8", "#bf7f2f", "#7a4f9d"])
+        ax.set_ylabel("Seconds")
+        ax.tick_params(axis="x", rotation=20)
+        return fig
+
+    def success_bar(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        labels = ["full ok", "adaptive ok", "random ok", "failed"]
+        vals = [
+            float(metrics.get("full_success_count", 0.0) or 0.0),
+            float(metrics.get("adaptive_success_count", 0.0) or 0.0),
+            float(metrics.get("random_success_count", 0.0) or 0.0),
+            float(metrics.get("failed_docking_count", 0.0) or 0.0),
+        ]
+        ax.bar(labels, vals, color=["#7a9d54", "#3b6ea8", "#bf7f2f", "#b14d4d"])
+        ax.set_ylabel("Ligands")
+        ax.tick_params(axis="x", rotation=15)
+        return fig
+
+    def model_scatter(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        xs = _floats(adaptive_rows, "model_score")
+        ys = _floats(adaptive_rows, "SCORE")
+        n = min(len(xs), len(ys))
+        ax.scatter(xs[:n], ys[:n], color="#3b6ea8")
+        ax.set_xlabel("Model score")
+        ax.set_ylabel("rDock SCORE")
+        return fig
+
+    plot_specs = [
+        ("cumulative_best_score.png", cumulative_plot),
+        ("adaptive_random_full_percentile.png", percentile_bar),
+        ("runtime_summary.png", runtime_bar),
+        ("success_failure_summary.png", success_bar),
+    ]
+    if _floats(adaptive_rows, "model_score"):
+        plot_specs.append(("model_vs_rdock_score.png", model_scatter))
+    for name, fn in plot_specs:
+        if path := _plot_or_skip(pdir, name, fn):
+            paths.append(path)
+        else:
+            fallback = full_scores
+            if name == "adaptive_random_full_percentile.png":
+                fallback = [
+                    float(metrics.get("adaptive_best_percentile_of_full", 0.0) or 0.0),
+                    float(metrics.get("random_best_percentile_of_full", 0.0) or 0.0),
+                    float(metrics.get("full_best_percentile_of_full", 100.0) or 100.0),
+                ]
+            paths.append(_simple_plot(pdir / name, fallback, "bar" if "summary" in name or "percentile" in name else "hist"))
+    return paths
+
+
+def plot_multifidelity_outputs(
+    trace_csv: str | Path,
+    final_hits_csv: str | Path,
+    random_csv: str | Path,
+    full_csv: str | Path,
+    metrics_json: str | Path,
+    plot_dir: str | Path,
+) -> list[str]:
+    pdir = Path(plot_dir)
+    pdir.mkdir(parents=True, exist_ok=True)
+    trace_rows = _read_rows(trace_csv) if Path(trace_csv).exists() else []
+    final_rows = _read_rows(final_hits_csv) if Path(final_hits_csv).exists() else []
+    random_rows = _read_rows(random_csv) if Path(random_csv).exists() else []
+    full_rows = _read_rows(full_csv) if Path(full_csv).exists() else []
+    metrics = json.loads(Path(metrics_json).read_text(encoding="utf-8")) if Path(metrics_json).exists() else {}
+    paths: list[str] = []
+    if not trace_rows:
+        return paths
+
+    def cumulative_best_vs_cost(rows: list[dict[str, str]], score_key: str = "current_best_score"):  # type: ignore[no-untyped-def]
+        ordered = sorted(rows, key=lambda row: (_float_or_zero(row.get("n_rdock_runs_total_spent", 0.0)), _float_or_zero(row.get("selected_fidelity_runs", 0.0))))
+        xs: list[float] = []
+        ys: list[float] = []
+        current = float("inf")
+        for row in ordered:
+            score = _float_or_zero(row.get(score_key, row.get("SCORE", 0.0)))
+            if score == 0.0 and row.get(score_key, row.get("SCORE", "")) in ("", None):
+                continue
+            current = min(current, score)
+            xs.append(_float_or_zero(row.get("n_rdock_runs_total_spent", 0.0)))
+            ys.append(current)
+        return xs, ys
+
+    def best_vs_cost(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(7, 4))
+        xs, ys = cumulative_best_vs_cost(trace_rows)
+        if xs and ys:
+            ax.plot(xs, ys, label="multifidelity")
+        random_vals = sorted(_floats(random_rows, "final_score") or _floats(random_rows, "SCORE"))
+        if random_vals:
+            ax.axhline(random_vals[0], color="#bf7f2f", linestyle="--", label="random best")
+        full_vals = sorted(_floats(full_rows, "SCORE"))
+        if full_vals:
+            ax.axhline(full_vals[0], color="#7a9d54", linestyle=":", label="full best")
+        ax.set_xlabel("Total rDock runs spent")
+        ax.set_ylabel("Best SCORE so far")
+        ax.legend()
+        return fig
+
+    def best_vs_walltime(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(7, 4))
+        ordered = sorted(trace_rows, key=lambda row: _float_or_zero(row.get("timing_docking_seconds", 0.0)) + _float_or_zero(row.get("timing_training_seconds", 0.0)))
+        xs: list[float] = []
+        ys: list[float] = []
+        elapsed = 0.0
+        current = float("inf")
+        for row in ordered:
+            score = _float_or_zero(row.get("current_best_score", row.get("SCORE", 0.0)))
+            elapsed += _float_or_zero(row.get("timing_docking_seconds", 0.0)) + _float_or_zero(row.get("timing_training_seconds", 0.0))
+            current = min(current, score)
+            xs.append(elapsed)
+            ys.append(current)
+        if xs and ys:
+            ax.plot(xs, ys, color="#3b6ea8")
+        ax.set_xlabel("Walltime (s)")
+        ax.set_ylabel("Best SCORE so far")
+        return fig
+
+    def fidelity_counts(plt):  # type: ignore[no-untyped-def]
+        counts: dict[str, int] = {}
+        for row in trace_rows:
+            level = str(row.get("selected_fidelity_runs", ""))
+            counts[level] = counts.get(level, 0) + 1
+        labels = sorted(counts, key=lambda x: int(x or 0))
+        vals = [counts[label] for label in labels]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        ax.bar(labels, vals, color="#3b6ea8")
+        ax.set_xlabel("Fidelity runs")
+        ax.set_ylabel("Ligands screened")
+        return fig
+
+    def promotion_funnel(plt):  # type: ignore[no-untyped-def]
+        counts: dict[str, int] = {}
+        for row in trace_rows:
+            level = str(row.get("selected_fidelity_runs", ""))
+            counts[level] = counts.get(level, 0) + 1
+        labels = sorted(counts, key=lambda x: int(x or 0))
+        vals = [counts[label] for label in labels]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        ax.plot(range(len(vals)), vals, marker="o", color="#7a4f9d")
+        ax.set_xticks(range(len(vals)))
+        ax.set_xticklabels(labels)
+        ax.set_xlabel("Fidelity runs")
+        ax.set_ylabel("Ligands")
+        return fig
+
+    def percentile_bar(plt):  # type: ignore[no-untyped-def]
+        labels = ["multifidelity", "random", "single", "full"]
+        vals = [
+            float(metrics.get("multifidelity_percentile_vs_full", 0.0) or 0.0),
+            float(metrics.get("random_percentile_vs_full", 0.0) or 0.0),
+            float(metrics.get("single_fidelity_percentile_vs_full", 0.0) or 0.0),
+            100.0,
+        ]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        ax.bar(labels, vals, color=["#3b6ea8", "#bf7f2f", "#7a4f9d", "#7a9d54"])
+        ax.set_ylim(0, 100)
+        ax.set_ylabel("Percentile in full ranking")
+        return fig
+
+    def score_by_level(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(7, 4))
+        levels = sorted({str(row.get("selected_fidelity_runs", "")) for row in trace_rows}, key=lambda x: int(x or 0))
+        for level in levels:
+            vals = [_float_or_zero(row.get("SCORE", 0.0)) for row in trace_rows if str(row.get("selected_fidelity_runs", "")) == level and row.get("SCORE", "") not in ("", None)]
+            if vals:
+                ax.hist(vals, bins=min(25, max(5, len(vals) // 3)), alpha=0.45, label=level)
+        ax.set_xlabel("SCORE")
+        ax.set_ylabel("Records")
+        ax.legend(title="runs")
+        return fig
+
+    def intra_hist(plt):  # type: ignore[no-untyped-def]
+        vals = [_float_or_zero(row.get("SCORE.INTRA", 0.0)) for row in trace_rows if row.get("SCORE.INTRA", "") not in ("", None)]
+        fig, ax = plt.subplots(figsize=(7, 4))
+        ax.hist(vals, bins=min(30, max(5, len(vals) // 3)), color="#bf7f2f")
+        ax.set_xlabel("SCORE.INTRA")
+        ax.set_ylabel("Records")
+        return fig
+
+    def score_vs_intra(plt):  # type: ignore[no-untyped-def]
+        xs = [_float_or_zero(row.get("SCORE.INTRA", 0.0)) for row in trace_rows if row.get("SCORE", "") not in ("", None) and row.get("SCORE.INTRA", "") not in ("", None)]
+        ys = [_float_or_zero(row.get("SCORE", 0.0)) for row in trace_rows if row.get("SCORE", "") not in ("", None) and row.get("SCORE.INTRA", "") not in ("", None)]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        if xs and ys:
+            ax.scatter(xs, ys, c=["#b14d4d" if _boolish(row.get("intra_outlier", "")) else "#3b6ea8" for row in trace_rows[: min(len(xs), len(trace_rows))]], alpha=0.7)
+        ax.set_xlabel("SCORE.INTRA")
+        ax.set_ylabel("SCORE")
+        return fig
+
+    def top_hits_bar(plt):  # type: ignore[no-untyped-def]
+        ordered = sorted(
+            [row for row in final_rows if str(row.get("is_final_fidelity", "")).lower() in {"true", "1"}],
+            key=lambda row: _float_or_zero(row.get("final_score", row.get("current_best_score", 0.0))),
+        )[:20]
+        labels = [str(row.get("ligand_id", "")) for row in ordered]
+        vals = [_float_or_zero(row.get("final_score", row.get("current_best_score", 0.0))) for row in ordered]
+        fig, ax = plt.subplots(figsize=(9, 4))
+        ax.bar(range(len(vals)), vals, color="#7a9d54")
+        ax.set_xticks(range(len(vals)))
+        ax.set_xticklabels(labels, rotation=60, ha="right", fontsize=8)
+        ax.set_ylabel("Final SCORE")
+        return fig
+
+    def training_vs_docking(plt):  # type: ignore[no-untyped-def]
+        fig, ax = plt.subplots(figsize=(6, 4))
+        ax.bar(
+            ["training", "docking", "overhead"],
+            [
+                float(metrics.get("training_time_seconds", 0.0) or 0.0),
+                float(metrics.get("docking_time_seconds", 0.0) or 0.0),
+                float(metrics.get("overhead_time_seconds", 0.0) or 0.0),
+            ],
+            color=["#7a4f9d", "#3b6ea8", "#bf7f2f"],
+        )
+        ax.set_ylabel("Seconds")
+        return fig
+
+    plot_specs = [
+        ("cumulative_best_final_score_vs_runs.png", best_vs_cost),
+        ("cumulative_best_score_vs_walltime.png", best_vs_walltime),
+        ("ligands_per_fidelity_level.png", fidelity_counts),
+        ("promotion_funnel.png", promotion_funnel),
+        ("adaptive_vs_random_vs_full_percentile.png", percentile_bar),
+        ("score_distribution_by_fidelity.png", score_by_level),
+        ("score_intra_distribution.png", intra_hist),
+        ("score_vs_score_intra.png", score_vs_intra),
+        ("top_final_hits.png", top_hits_bar),
+        ("training_vs_docking_time.png", training_vs_docking),
+    ]
+    for name, fn in plot_specs:
+        if path := _plot_or_skip(pdir, name, fn):
+            paths.append(path)
+        else:
+            vals = _floats(trace_rows, "SCORE")
+            paths.append(_simple_plot(pdir / name, vals, "bar" if "percentile" in name or "fidelity" in name or "top_" in name or "training" in name else "hist"))
+    return paths

docking_pipeline/sdf.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import csv
+import math
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+from .provenance import RDockPipelineError, require_file
+
+TAG_RE = re.compile(r"^>\s*<\s*([^>]+?)\s*>", flags=re.IGNORECASE)
+
+
+@dataclass(frozen=True)
+class SDFRecord:
+    block: str
+    index: int
+    ligand_id: str
+    score: float | None
+    tags: dict[str, str]
+    numeric_tags: dict[str, float]
+
+
+def split_sdf_text(text: str) -> list[str]:
+    blocks: list[str] = []
+    for part in text.split("$$$$"):
+        body = part.strip()
+        if body:
+            blocks.append(body + "\n$$$$\n")
+    return blocks
+
+
+def split_sdf_file(path: str | Path) -> list[str]:
+    source = require_file(path, "SDF file")
+    blocks = split_sdf_text(source.read_text(encoding="utf-8", errors="ignore"))
+    if not blocks:
+        raise RDockPipelineError(f"No SDF records found in {source}")
+    return blocks
+
+
+def parse_tags(block: str) -> dict[str, str]:
+    lines = block.splitlines()
+    tags: dict[str, str] = {}
+    i = 0
+    while i < len(lines):
+        m = TAG_RE.match(lines[i].strip())
+        if not m:
+            i += 1
+            continue
+        key = m.group(1).strip()
+        values: list[str] = []
+        j = i + 1
+        while j < len(lines) and lines[j].strip() and lines[j].strip() != "$$$$" and not TAG_RE.match(lines[j].strip()):
+            values.append(lines[j].strip())
+            j += 1
+        tags[key] = "\n".join(values).strip()
+        i = j
+    return tags
+
+
+def _safe_float(value: Any) -> float | None:
+    try:
+        out = float(str(value).strip())
+    except Exception:
+        return None
+    if not math.isfinite(out):
+        return None
+    return out
+
+
+def _record_name(block: str, fallback: str) -> str:
+    first = block.splitlines()[0].strip() if block.splitlines() else ""
+    return first or fallback
+
+
+def ligand_id_from_block(block: str, tags: dict[str, str], index: int) -> str:
+    for key in ("ligand_id", "LigandID", "LIGAND_ID", "ID", "Name", "_Name"):
+        value = tags.get(key)
+        if value:
+            return value.split()[0].strip()
+    return _record_name(block, f"ligand_{index:06d}").split()[0].strip()
+
+
+def parse_rdock_sdf_records(path: str | Path, require_score: bool = True) -> list[SDFRecord]:
+    records: list[SDFRecord] = []
+    for idx, block in enumerate(split_sdf_file(path)):
+        tags = parse_tags(block)
+        numeric = {k: v for k, raw in tags.items() if (v := _safe_float(raw)) is not None}
+        score = numeric.get("SCORE")
+        if require_score and score is None:
+            raise RDockPipelineError(f"Missing required rDock SCORE field in SDF record {idx} of {path}")
+        records.append(
+            SDFRecord(
+                block=block,
+                index=idx,
+                ligand_id=ligand_id_from_block(block, tags, idx),
+                score=score,
+                tags=tags,
+                numeric_tags=numeric,
+            )
+        )
+    return records
+
+
+def write_sdf_records(records: Iterable[SDFRecord], path: str | Path) -> Path:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text("".join(rec.block for rec in records), encoding="utf-8")
+    return target
+
+
+def write_sdf_blocks(blocks: Iterable[str], path: str | Path) -> Path:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text("".join(blocks), encoding="utf-8")
+    return target
+
+
+def best_per_ligand(records: Iterable[SDFRecord]) -> list[SDFRecord]:
+    best: dict[str, SDFRecord] = {}
+    for rec in records:
+        if rec.score is None:
+            raise RDockPipelineError(f"Cannot rank ligand {rec.ligand_id}: missing SCORE")
+        prev = best.get(rec.ligand_id)
+        if prev is None or float(rec.score) < float(prev.score):
+            best[rec.ligand_id] = rec
+    return sorted(best.values(), key=lambda r: (float(r.score), r.ligand_id, r.index))
+
+
+def records_to_rows(records: Iterable[SDFRecord]) -> list[dict[str, object]]:
+    rows: list[dict[str, object]] = []
+    for rec in records:
+        row: dict[str, object] = {
+            "pose_index": rec.index,
+            "ligand_id": rec.ligand_id,
+            "SCORE": rec.score,
+        }
+        for key, value in sorted(rec.numeric_tags.items()):
+            row[key] = value
+        rows.append(row)
+    return rows
+
+
+def write_rows_csv(rows: list[dict[str, object]], path: str | Path) -> Path:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    fields: list[str] = []
+    for row in rows:
+        for key in row:
+            if key not in fields:
+                fields.append(key)
+    with target.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows(rows)
+    return target

docking_pipeline/validation.py

@@ -0,0 +1,708 @@
+from __future__ import annotations
+
+import csv
+import gzip
+import json
+import os
+import re
+import shutil
+import tarfile
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from statistics import median
+from typing import Iterable
+
+from .metrics import enrichment_rows, validation_metrics_from_rows
+from .provenance import CommandRecord, CommandRunner, RDockPipelineError, fail_if_bad_command, require_executable, require_file
+from .reports.plots import plot_astex_outputs, plot_dud_outputs
+from .sdf import best_per_ligand, parse_rdock_sdf_records, records_to_rows, split_sdf_file, write_rows_csv, write_sdf_blocks, write_sdf_records
+
+VALIDATION_URL = "https://rdock.github.io/validation-sets/"
+
+
+@dataclass(frozen=True)
+class ValidationSystem:
+    system_id: str
+    path: str
+    receptor_prm: str
+    dock_prm: str
+    ligand_sdf: str = ""
+    ligprep_sdf: str = ""
+    crystal_sdf: str = ""
+
+
+def resolve_jobs(jobs: int | str = "auto", cpu_fraction: float = 0.85) -> int:
+    if str(jobs).lower() == "auto":
+        cpus = os.cpu_count() or 1
+        reserve = 1 if cpus <= 4 else 2
+        return max(1, min(cpus - reserve, int(cpus * float(cpu_fraction))))
+    return max(1, int(jobs))
+
+
+def _rdock_env() -> dict[str, str]:
+    root = os.environ.get("RBT_ROOT")
+    if root:
+        return {"RBT_ROOT": root}
+    for candidate in (Path("/opt/homebrew/opt/rdock/share"), Path("/usr/local/opt/rdock/share")):
+        if (candidate / "data" / "RbtElements.dat").exists():
+            return {"RBT_ROOT": str(candidate)}
+    cellar = Path("/opt/homebrew/Cellar/rdock")
+    if cellar.exists():
+        for candidate in sorted(cellar.glob("*/share"), reverse=True):
+            if (candidate / "data" / "RbtElements.dat").exists():
+                return {"RBT_ROOT": str(candidate)}
+    return {}
+
+
+def _system_id_from_prm(path: Path) -> str:
+    name = path.stem
+    return re.sub(r"_?rdock$", "", name, flags=re.IGNORECASE)
+
+
+def _find_first(candidates: Iterable[Path]) -> Path | None:
+    for p in candidates:
+        if p.exists() and p.is_file() and p.stat().st_size > 0:
+            return p
+    return None
+
+
+def _find_dock_prm(system_dir: Path) -> Path | None:
+    candidates = [system_dir / "dock.prm"] + [parent / "dock.prm" for parent in list(system_dir.parents)[:3]]
+    rbt_root = os.environ.get("RBT_ROOT")
+    if rbt_root:
+        candidates.extend([Path(rbt_root) / "data" / "scripts" / "dock.prm", Path(rbt_root) / "data" / "dock.prm"])
+    candidates.extend(
+        [
+            Path("/opt/homebrew/share/rdock/data/scripts/dock.prm"),
+            Path("/opt/homebrew/opt/rdock/share/data/scripts/dock.prm"),
+        ]
+    )
+    candidates.extend(sorted(Path("/opt/homebrew/Cellar/rdock").glob("*/share/data/scripts/dock.prm")) if Path("/opt/homebrew/Cellar/rdock").exists() else [])
+    return _find_first(candidates)
+
+
+def discover_validation_systems(data_dir: str | Path, set_name: str) -> list[ValidationSystem]:
+    root = Path(data_dir)
+    if not root.exists():
+        return []
+    systems: dict[str, ValidationSystem] = {}
+    for prm in sorted(root.rglob("*_rdock.prm")):
+        system_dir = prm.parent
+        system_id = _system_id_from_prm(prm)
+        dock_prm = _find_dock_prm(system_dir)
+        if dock_prm is None:
+            local = list(system_dir.rglob("dock.prm"))
+            dock_prm = local[0] if local else None
+        sdf_files = sorted(list(system_dir.glob("*.sd")) + list(system_dir.glob("*.sdf")))
+        gz_sdfs = sorted(list(system_dir.glob("*.sd.gz")) + list(system_dir.glob("*.sdf.gz")))
+        ligand_sdf = _find_first(
+            [
+                system_dir / f"{system_id}_ligand.sd",
+                system_dir / f"{system_id}_ligand.sdf",
+                system_dir / "ligand.sd",
+                system_dir / "ligand.sdf",
+            ]
+            + [p for p in sdf_files if "ligand" in p.name.lower() or "crystal" in p.name.lower()]
+            + sdf_files
+        )
+        ligprep_sdf = _find_first(
+            [
+                system_dir / f"{system_id}_ligprep.sdf",
+                system_dir / f"{system_id}_ligprep.sd",
+            ]
+            + [p for p in sdf_files if "ligprep" in p.name.lower()]
+            + [p for p in gz_sdfs if "ligprep" in p.name.lower()]
+        )
+        if set_name.lower() == "dud" and ligprep_sdf is None:
+            continue
+        systems[system_id] = ValidationSystem(
+            system_id=system_id,
+            path=str(system_dir),
+            receptor_prm=str(prm),
+            dock_prm=str(dock_prm or ""),
+            ligand_sdf=str(ligand_sdf or ""),
+            ligprep_sdf=str(ligprep_sdf or ""),
+            crystal_sdf=str(ligand_sdf or ""),
+        )
+    return [systems[k] for k in sorted(systems)]
+
+
+def _actionable_missing_system(data_dir: Path, set_name: str, system: str | None) -> RDockPipelineError:
+    expected = data_dir / (system or "<system>")
+    return RDockPipelineError(
+        "Missing rDock validation data.\n"
+        f"Expected path or discoverable system files under: {expected}\n"
+        f"Validation set: {set_name}\n"
+        f"Official validation sets: {VALIDATION_URL}\n"
+        "Use one of:\n"
+        f"  python -m docking_pipeline validate-rdock --set {set_name} --data-dir {data_dir} --list-systems\n"
+        f"  python -m docking_pipeline validate-rdock --set {set_name} --system {system or '<id>'} --data-dir {data_dir} --out results/benchmarks/{set_name}_{system or '<id>'} --download-url <official_tar.gz> --download-if-missing\n"
+        "or manually download/extract the official rDock validation set and pass its extracted directory via --data-dir."
+    )
+
+
+def download_validation_set(download_url: str, data_dir: str | Path, force: bool = False) -> Path:
+    target = Path(data_dir)
+    if target.exists() and any(target.iterdir()) and not force:
+        return target
+    target.mkdir(parents=True, exist_ok=True)
+    archive = target / Path(download_url).name
+    urllib.request.urlretrieve(download_url, archive)
+    with tarfile.open(archive, "r:*") as tar:
+        tar.extractall(target)
+    return target
+
+
+def ensure_validation_data(data_dir: str | Path, set_name: str, download_url: str | None, download_if_missing: bool, force: bool = False) -> Path:
+    root = Path(data_dir)
+    if root.exists() and discover_validation_systems(root, set_name):
+        return root
+    if download_if_missing:
+        if not download_url:
+            raise RDockPipelineError(
+                f"--download-if-missing was set but --download-url was not provided. Official validation sets: {VALIDATION_URL}"
+            )
+        download_validation_set(download_url, root, force=force)
+    return root
+
+
+def resolve_systems(
+    data_dir: str | Path,
+    set_name: str,
+    system: str | None = None,
+    system_list: str | Path | None = None,
+    max_systems: int | None = None,
+) -> list[ValidationSystem]:
+    root = Path(data_dir)
+    systems = discover_validation_systems(root, set_name)
+    if not systems:
+        raise _actionable_missing_system(root, set_name, system)
+    wanted: set[str] | None = None
+    if system:
+        wanted = {system}
+    if system_list:
+        ids = [line.strip() for line in Path(system_list).read_text(encoding="utf-8").splitlines() if line.strip()]
+        wanted = (wanted or set()) | set(ids)
+    if wanted is not None:
+        systems = [s for s in systems if s.system_id in wanted]
+        if not systems:
+            raise _actionable_missing_system(root, set_name, system or ",".join(sorted(wanted)))
+    if max_systems is not None:
+        systems = systems[: int(max_systems)]
+    return systems
+
+
+def _copy_system(src: Path, out_dir: Path, force: bool) -> Path:
+    dst = out_dir / "rdock" / src.name
+    if dst.exists():
+        if not force:
+            return dst
+        shutil.rmtree(dst)
+    shutil.copytree(src, dst)
+    return dst
+
+
+def _gunzip_if_needed(path: Path) -> Path:
+    if path.exists() and path.suffix != ".gz":
+        return path
+    if path.suffix == ".gz":
+        out = path.with_suffix("")
+        if not out.exists():
+            with gzip.open(path, "rb") as src, out.open("wb") as dst:
+                shutil.copyfileobj(src, dst)
+        return out
+    gz = path.with_suffix(path.suffix + ".gz")
+    if gz.exists():
+        return _gunzip_if_needed(gz)
+    return require_file(path, "ligand-prepped SDF")
+
+
+def _run_rbdock_parallel(
+    runner: CommandRunner,
+    work: Path,
+    prm: Path,
+    dock_prm: Path,
+    ligand_sdf: Path,
+    out_prefix: str,
+    n_runs: int,
+    jobs: int,
+) -> tuple[Path, list[CommandRecord]]:
+    rbdock = require_executable("rbdock")
+    blocks = split_sdf_file(ligand_sdf)
+    chunk_dir = work / "chunks"
+    chunk_dir.mkdir(exist_ok=True)
+    chunk_count = min(max(1, jobs), len(blocks))
+    chunks: list[Path] = []
+    for idx in range(chunk_count):
+        chunk_blocks = blocks[idx::chunk_count]
+        chunk = chunk_dir / f"chunk_{idx:03d}.sdf"
+        write_sdf_blocks(chunk_blocks, chunk)
+        chunks.append(chunk)
+
+    def run_one(idx: int, chunk: Path) -> tuple[int, CommandRecord, Path]:
+        prefix = work / f"{out_prefix}_chunk_{idx:03d}"
+        rec = runner.run(
+            f"rbdock_chunk_{idx:03d}",
+            [rbdock, "-r", str(prm.name), "-p", str(dock_prm), "-n", str(int(n_runs)), "-i", str(chunk.relative_to(work)), "-o", str(prefix.name)],
+            work,
+            work / f"{out_prefix}_chunk_{idx:03d}.stdout.log",
+            work / f"{out_prefix}_chunk_{idx:03d}.stderr.log",
+            env=_rdock_env(),
+        )
+        return idx, rec, prefix.with_suffix(".sd")
+
+    outputs: dict[int, Path] = {}
+    records: list[CommandRecord] = []
+    with ThreadPoolExecutor(max_workers=chunk_count) as pool:
+        futures = [pool.submit(run_one, idx, chunk) for idx, chunk in enumerate(chunks)]
+        for fut in as_completed(futures):
+            idx, rec, out_sd = fut.result()
+            fail_if_bad_command(rec, f"rbdock chunk {idx}")
+            require_file(out_sd, f"rDock output chunk {idx}")
+            outputs[idx] = out_sd
+            records.append(rec)
+    merged = work / f"{out_prefix}.sd"
+    all_blocks: list[str] = []
+    for idx in sorted(outputs):
+        all_blocks.extend(split_sdf_file(outputs[idx]))
+    write_sdf_blocks(all_blocks, merged)
+    return merged, records
+
+
+def _parse_rmsd_stdout(text: str) -> list[float]:
+    vals: list[float] = []
+    for token in re.findall(r"[-+]?(?:\d+\.\d+|\d+)", text):
+        try:
+            value = float(token)
+        except Exception:
+            continue
+        if 0.0 <= value < 100.0:
+            vals.append(value)
+    return vals
+
+
+def _sdf_pose_coords(path: Path) -> list[list[list[float]]]:
+    poses: list[list[list[float]]] = []
+    for block in split_sdf_file(path):
+        lines = block.splitlines()
+        if len(lines) < 4:
+            continue
+        try:
+            atom_count = int(lines[3][0:3])
+        except Exception:
+            continue
+        coords: list[list[float]] = []
+        for line in lines[4 : 4 + atom_count]:
+            try:
+                coords.append([float(line[0:10]), float(line[10:20]), float(line[20:30])])
+            except Exception:
+                parts = line.split()
+                if len(parts) >= 3:
+                    try:
+                        coords.append([float(parts[0]), float(parts[1]), float(parts[2])])
+                    except Exception:
+                        continue
+        if coords:
+            poses.append(coords)
+    return poses
+
+
+def _rmsd_same_order(a: list[list[float]], b: list[list[float]]) -> float:
+    n = min(len(a), len(b))
+    if n == 0:
+        return float("nan")
+    return (sum((a[i][0] - b[i][0]) ** 2 + (a[i][1] - b[i][1]) ** 2 + (a[i][2] - b[i][2]) ** 2 for i in range(n)) / n) ** 0.5
+
+
+def _internal_rmsds(reference_sdf: Path, poses_sdf: Path) -> list[float]:
+    ref = _sdf_pose_coords(reference_sdf)
+    poses = _sdf_pose_coords(poses_sdf)
+    if not ref:
+        return []
+    return [_rmsd_same_order(ref[0], pose) for pose in poses]
+
+
+def _write_csv(path: Path, rows: list[dict[str, object]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fields: list[str] = []
+    for row in rows:
+        for k in row:
+            if k not in fields:
+                fields.append(k)
+    with path.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def _empty_standard_outputs(root: Path) -> None:
+    for name in ("target", "ligands", "rdock", "poses", "tables", "metrics", "plots"):
+        (root / name).mkdir(parents=True, exist_ok=True)
+
+
+def _copy_receptor_to_target(work: Path, system: ValidationSystem, root: Path) -> Path | None:
+    target_dir = root / "target"
+    target_dir.mkdir(parents=True, exist_ok=True)
+    prm_stem = Path(system.receptor_prm).stem
+    candidates = [
+        work / f"{prm_stem}.mol2",
+        work / f"{system.system_id}_rdock.mol2",
+        work / f"{system.system_id}.mol2",
+    ]
+    candidates.extend(sorted(work.glob("*.mol2")))
+    receptor = _find_first(candidates)
+    if receptor is None:
+        return None
+    dst = target_dir / receptor.name
+    shutil.copy2(receptor, dst)
+    return dst
+
+
+def validate_astex_system(
+    system: ValidationSystem,
+    root: Path,
+    n_runs: int,
+    jobs: int,
+    force: bool = False,
+) -> dict[str, object]:
+    _empty_standard_outputs(root)
+    work = _copy_system(Path(system.path), root, force=force)
+    _copy_receptor_to_target(work, system, root)
+    runner = CommandRunner(root / "commands.log")
+    for exe in ("rbcavity", "rbdock", "sdsort", "sdrmsd"):
+        require_executable(exe)
+    prm = require_file(work / Path(system.receptor_prm).name, "ASTEX rDock receptor prm")
+    dock_prm = require_file(system.dock_prm, "ASTEX dock.prm")
+    ligand = require_file(work / Path(system.ligand_sdf).name, "ASTEX ligand SDF")
+    rec = runner.run("rbcavity", ["rbcavity", "-r", prm.name, "-was"], work, work / "rbcavity.stdout.log", work / "rbcavity.stderr.log", env=_rdock_env())
+    fail_if_bad_command(rec, "ASTEX rbcavity")
+    out_sd, _ = _run_rbdock_parallel(runner, work, prm, dock_prm, ligand, f"{system.system_id}_docking_out", n_runs, jobs)
+    rec = runner.run(
+        "sdsort",
+        ["/bin/sh", "-c", f"sdsort -n -f'SCORE' {out_sd.name} > {system.system_id}_docking_out_sorted.sd"],
+        work,
+        work / "sdsort.stdout.log",
+        work / "sdsort.stderr.log",
+        env=_rdock_env(),
+    )
+    fail_if_bad_command(rec, "ASTEX sdsort")
+    sorted_sd = require_file(work / f"{system.system_id}_docking_out_sorted.sd", "ASTEX sorted SDF")
+    rmsd_source = "sdrmsd"
+    rmsd_diagnostic = ""
+    rec = runner.run("sdrmsd", ["sdrmsd", ligand.name, sorted_sd.name], work, work / "sdrmsd.stdout.log", work / "sdrmsd.stderr.log", env=_rdock_env())
+    try:
+        fail_if_bad_command(rec, "ASTEX sdrmsd")
+        rmsds = _parse_rmsd_stdout(Path(rec.stdout_log).read_text(encoding="utf-8", errors="ignore"))
+    except RDockPipelineError as exc:
+        rmsd_source = "internal_same_atom_order_sdf_rmsd_after_sdrmsd_failure"
+        rmsd_diagnostic = str(exc)
+        rmsds = _internal_rmsds(ligand, sorted_sd)
+    top1 = rmsds[0] if rmsds else float("nan")
+    best = min(rmsds) if rmsds else float("nan")
+    shutil.copy2(out_sd, root / "poses" / "all_poses.sdf")
+    shutil.copy2(sorted_sd, root / "poses" / "best_per_ligand.sdf")
+    records = parse_rdock_sdf_records(out_sd)
+    sorted_records = parse_rdock_sdf_records(sorted_sd)
+    best_records = best_per_ligand(records)
+    write_rows_csv(records_to_rows(records), root / "tables" / "scores_long.csv")
+    write_rows_csv(records_to_rows(best_records), root / "tables" / "best_per_ligand.csv")
+    top1_score = sorted_records[0].numeric_tags.get("SCORE") if sorted_records else None
+    row = {
+        "system_id": system.system_id,
+        "top1_rmsd": top1,
+        "best_of_n_rmsd": best,
+        "top1_SCORE": top1_score,
+        "success_top1_rmsd_le_2A": bool(top1 <= 2.0),
+        "success_best_rmsd_le_2A": bool(best <= 2.0),
+        "n_poses": len(records),
+        "status": "success",
+        "rmsd_source": rmsd_source,
+        "rmsd_diagnostic": rmsd_diagnostic,
+    }
+    _write_csv(root / "tables" / "astex_system_summary.csv", [row])
+    metrics = {
+        **row,
+        "median_top1_rmsd": top1,
+        "median_best_rmsd": best,
+        "n_systems_total": 1,
+        "n_systems_successful": 1,
+        "n_systems_failed": 0,
+        "n_poses_total": len(records),
+    }
+    (root / "metrics" / "validation_metrics.json").write_text(json.dumps(metrics, indent=2), encoding="utf-8")
+    (root / "metrics" / "enrichment.csv").write_text("", encoding="utf-8")
+    plots = plot_astex_outputs(root / "tables" / "astex_system_summary.csv", root / "plots")
+    _write_validation_report(root, "ASTEX", [system], runner.records, metrics, plots)
+    return metrics
+
+
+def _read_dud_labels(work: Path) -> dict[str, int]:
+    labels: dict[str, int] = {}
+    for name, value in (("ligands.txt", 1), ("actives.txt", 1), ("decoys.txt", 0)):
+        p = work / name
+        if not p.exists():
+            continue
+        for line in p.read_text(encoding="utf-8", errors="ignore").splitlines():
+            parts = line.strip().split()
+            if parts:
+                labels[parts[0]] = value
+    return labels
+
+
+def validate_dud_system(system: ValidationSystem, root: Path, n_runs: int, jobs: int, force: bool = False) -> dict[str, object]:
+    _empty_standard_outputs(root)
+    work = _copy_system(Path(system.path), root, force=force)
+    _copy_receptor_to_target(work, system, root)
+    runner = CommandRunner(root / "commands.log")
+    for exe in ("rbcavity", "rbdock", "sdsort", "sdfilter", "sdreport"):
+        require_executable(exe)
+    prm = require_file(work / Path(system.receptor_prm).name, "DUD rDock receptor prm")
+    dock_prm = require_file(system.dock_prm, "DUD dock.prm")
+    ligprep = _gunzip_if_needed(work / Path(system.ligprep_sdf).name)
+    labels = _read_dud_labels(work)
+    if not labels:
+        raise RDockPipelineError(
+            "Missing DUD active/decoy label files for enrichment metrics.\n"
+            f"Expected `ligands.txt`/`actives.txt` and `decoys.txt` in: {work}\n"
+            "The official rDock ROC workflow requires these files to assign IsActive labels.\n"
+            "Add the label files for this DUD system, then rerun the same validate-rdock command."
+        )
+    rec = runner.run("rbcavity", ["rbcavity", "-r", prm.name, "-was"], work, work / "rbcavity.stdout.log", work / "rbcavity.stderr.log", env=_rdock_env())
+    fail_if_bad_command(rec, "DUD rbcavity")
+    out_sd, _ = _run_rbdock_parallel(runner, work, prm, dock_prm, ligprep, f"{system.system_id}_docking_out", n_runs, jobs)
+    records = parse_rdock_sdf_records(out_sd, require_score=True)
+    best_records = best_per_ligand(records)
+    best_sd = write_sdf_records(best_records, work / f"{system.system_id}_1poseperlig.sd")
+    rows = records_to_rows(best_records)
+    for row in rows:
+        row["label"] = labels.get(str(row["ligand_id"]), 0)
+    duplicate_count = len(records) - len({r.ligand_id for r in records})
+    metrics = validation_metrics_from_rows(rows)
+    metrics.update(
+        {
+            "active_count": sum(int(row.get("label", 0)) for row in rows),
+            "decoy_count": sum(1 - int(row.get("label", 0)) for row in rows),
+            "attempted_ligands": len(split_sdf_file(ligprep)),
+            "successful_ligands": len(rows),
+            "failed_ligands": max(0, len(split_sdf_file(ligprep)) - len(rows)),
+            "duplicate_ligand_ids": duplicate_count,
+            "missing_SCORE_count": 0,
+        }
+    )
+    shutil.copy2(out_sd, root / "poses" / "all_poses.sdf")
+    shutil.copy2(best_sd, root / "poses" / "best_per_ligand.sdf")
+    write_rows_csv(records_to_rows(records), root / "tables" / "scores_long.csv")
+    write_rows_csv(rows, root / "tables" / "best_per_ligand.csv")
+    _write_csv(root / "metrics" / "enrichment.csv", enrichment_rows([float(r["SCORE"]) for r in rows], [int(r["label"]) for r in rows]))
+    (root / "metrics" / "validation_metrics.json").write_text(json.dumps(metrics, indent=2), encoding="utf-8")
+    plots = plot_dud_outputs(root / "tables" / "best_per_ligand.csv", root / "metrics" / "enrichment.csv", root / "plots")
+    _write_validation_report(root, "DUD", [system], runner.records, metrics, plots)
+    return metrics
+
+
+def plan_validation(
+    set_name: str,
+    data_dir: str | Path,
+    systems: list[ValidationSystem],
+    out_dir: str | Path,
+    n_runs: int,
+    jobs: int | str,
+    cpu_fraction: float,
+) -> dict[str, object]:
+    resolved_jobs = resolve_jobs(jobs, cpu_fraction)
+    return {
+        "set": set_name,
+        "data_dir": str(data_dir),
+        "out": str(out_dir),
+        "n_runs": int(n_runs),
+        "jobs": resolved_jobs,
+        "system_count": len(systems),
+        "systems": [asdict(s) for s in systems],
+        "commands": [
+            f"rbcavity -r <system>_rdock.prm -was",
+            f"rbdock -r <system>_rdock.prm -p dock.prm -n {int(n_runs)} -i <ligands>.sd -o <out>",
+            "sdsort/sdrmsd for ASTEX or best-pose/enrichment reporting for DUD",
+        ],
+    }
+
+
+def validate_many(
+    set_name: str,
+    data_dir: str | Path,
+    out_dir: str | Path,
+    system: str | None = None,
+    system_list: str | Path | None = None,
+    max_systems: int | None = None,
+    n_runs: int = 100,
+    jobs: int | str = "auto",
+    cpu_fraction: float = 0.85,
+    download_url: str | None = None,
+    download_if_missing: bool = False,
+    force: bool = False,
+    dry_run: bool = False,
+    plan_only: bool = False,
+) -> dict[str, object]:
+    root_data = ensure_validation_data(data_dir, set_name, download_url, download_if_missing, force=force)
+    systems = resolve_systems(root_data, set_name, system, system_list, max_systems)
+    plan = plan_validation(set_name, root_data, systems, out_dir, n_runs, jobs, cpu_fraction)
+    out = Path(out_dir)
+    if dry_run or plan_only:
+        out.mkdir(parents=True, exist_ok=True)
+        (out / "validation_plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8")
+        return {"dry_run": bool(dry_run), "plan": plan}
+    if out.exists() and force:
+        shutil.rmtree(out)
+    out.mkdir(parents=True, exist_ok=True)
+    resolved_jobs = int(plan["jobs"])
+    rows: list[dict[str, object]] = []
+    failures: list[dict[str, object]] = []
+    metrics_by_system: list[dict[str, object]] = []
+    per_system_jobs = resolved_jobs if len(systems) == 1 else 1
+    system_order = {s.system_id: idx for idx, s in enumerate(systems)}
+
+    def run_system(s: ValidationSystem) -> tuple[int, ValidationSystem, dict[str, object] | None, dict[str, object], Exception | None]:
+        run_root = out / s.system_id if len(systems) > 1 else out
+        try:
+            if set_name.lower() == "astex":
+                metrics = validate_astex_system(s, run_root, n_runs=n_runs, jobs=per_system_jobs, force=force)
+                row = {
+                    "system_id": s.system_id,
+                        "top1_rmsd": metrics.get("top1_rmsd"),
+                        "best_of_n_rmsd": metrics.get("best_of_n_rmsd"),
+                        "top1_SCORE": metrics.get("top1_SCORE"),
+                        "success_top1_rmsd_le_2A": metrics.get("success_top1_rmsd_le_2A"),
+                        "success_best_rmsd_le_2A": metrics.get("success_best_rmsd_le_2A"),
+                    "n_poses": metrics.get("n_poses"),
+                    "status": "success",
+                }
+            elif set_name.lower() == "dud":
+                metrics = validate_dud_system(s, run_root, n_runs=n_runs, jobs=per_system_jobs, force=force)
+                row = {"system_id": s.system_id, "status": "success", **metrics}
+            else:
+                raise RDockPipelineError(f"Unsupported validation set: {set_name}")
+            return system_order[s.system_id], s, metrics, row, None
+        except Exception as exc:
+            return system_order[s.system_id], s, None, {"system_id": s.system_id, "status": "failed", "error": str(exc)}, exc
+
+    max_system_workers = min(resolved_jobs, len(systems))
+    results: list[tuple[int, ValidationSystem, dict[str, object] | None, dict[str, object], Exception | None]] = []
+    if max_system_workers > 1:
+        with ThreadPoolExecutor(max_workers=max_system_workers) as pool:
+            futures = [pool.submit(run_system, s) for s in systems]
+            for fut in as_completed(futures):
+                results.append(fut.result())
+    else:
+        results = [run_system(s) for s in systems]
+
+    for _, s, metrics, row, exc in sorted(results, key=lambda item: item[0]):
+        rows.append(row)
+        if exc is not None:
+            failures.append({"system_id": s.system_id, "error": str(exc)})
+            continue
+        if metrics is not None:
+            metrics_by_system.append({"system_id": s.system_id, **metrics})
+
+    # Per-system outputs are written by each worker. The root directory stores
+    # aggregate summaries, plots, manifests, and reports.
+    _empty_standard_outputs(out)
+    _write_csv(out / "tables" / f"{set_name.lower()}_system_summary.csv", rows)
+    if set_name.lower() == "astex":
+        top1 = [float(r["top1_rmsd"]) for r in rows if r.get("status") == "success"]
+        best_vals = [float(r["best_of_n_rmsd"]) for r in rows if r.get("status") == "success"]
+        aggregate = {
+            "n_systems_total": len(systems),
+            "n_systems_successful": len(top1),
+            "n_systems_failed": len(failures),
+            "median_top1_rmsd": median(top1) if top1 else None,
+            "median_best_rmsd": median(best_vals) if best_vals else None,
+            "success_top1_rmsd_le_2A": sum(1 for x in top1 if x <= 2.0),
+            "success_best_rmsd_le_2A": sum(1 for x in best_vals if x <= 2.0),
+            "n_poses_total": sum(int(r.get("n_poses", 0) or 0) for r in rows),
+            "failures": failures,
+        }
+        plots = plot_astex_outputs(out / "tables" / f"{set_name.lower()}_system_summary.csv", out / "plots")
+    else:
+        aggregate = {
+            "n_systems_total": len(systems),
+            "n_systems_successful": len(metrics_by_system),
+            "n_systems_failed": len(failures),
+            "failures": failures,
+        }
+        plots = []
+    (out / "metrics" / "validation_metrics.json").write_text(json.dumps(aggregate, indent=2), encoding="utf-8")
+    _write_validation_report(out, set_name.upper(), systems, [], aggregate, plots)
+    return {"metrics": aggregate, "systems": rows}
+
+
+def validate_astex(data_dir: str | Path, system: str, out_dir: str | Path, n_runs: int = 100, jobs: int | str = 1) -> dict[str, object]:
+    result = validate_many("astex", data_dir, out_dir, system=system, n_runs=n_runs, jobs=jobs)
+    return dict(result.get("metrics", {}))
+
+
+def validate_dud(data_dir: str | Path, system: str, out_dir: str | Path, n_runs: int = 100, jobs: int | str = 1) -> dict[str, object]:
+    result = validate_many("dud", data_dir, out_dir, system=system, n_runs=n_runs, jobs=jobs)
+    return dict(result.get("metrics", {}))
+
+
+def _write_validation_report(
+    root: Path,
+    set_name: str,
+    systems: list[ValidationSystem],
+    commands: list[CommandRecord],
+    metrics: dict[str, object],
+    plots: list[str],
+) -> None:
+    manifest = {
+        "validation_set": set_name,
+        "engine": "real-rdock-official-workflow",
+        "systems": [asdict(s) for s in systems],
+        "commands": [c.to_dict() for c in commands],
+        "metrics": metrics,
+        "plots": plots,
+        "artifacts": {
+            "report": str(root / "report.md"),
+            "manifest": str(root / "manifest.json"),
+            "config": str(root / "config.yaml"),
+            "commands": str(root / "commands.log"),
+            "tables": str(root / "tables"),
+            "metrics": str(root / "metrics"),
+            "plots": str(root / "plots"),
+        },
+    }
+    (root / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+    (root / "config.yaml").write_text(f"validation_set: {set_name}\nsystems: {[s.system_id for s in systems]}\n", encoding="utf-8")
+    top_lines = []
+    for item in list(metrics.items())[:20]:
+        top_lines.append(f"- {item[0]}: `{item[1]}`")
+    plot_lines = [f"- `{p}`" for p in plots] or ["- No plots generated; see `plots/skipped_plots.json` if present."]
+    (root / "report.md").write_text(
+        "\n".join(
+            [
+                f"# {set_name} rDock Validation",
+                "",
+                "## Input Summary",
+                f"- Systems: `{', '.join(s.system_id for s in systems)}`",
+                f"- System count: `{len(systems)}`",
+                "",
+                "## Metrics",
+                *top_lines,
+                "",
+                "## Commands",
+                f"- Command log: `{root / 'commands.log'}`",
+                "- Per-system command logs are stored under each system run directory for multi-system runs.",
+                "",
+                "## Plots",
+                *plot_lines,
+                "",
+                "## Skipped Steps",
+                "- Browser bundle export was removed from the production pipeline.",
+                "- No mock docking or surrogate scores are used.",
+                "",
+                "## Diagnostics",
+                f"- Failures: `{json.dumps(metrics.get('failures', []))}`",
+            ]
+        ),
+        encoding="utf-8",
+    )

environment.yml

@@ -0,0 +1,12 @@
+name: portable-rdock-pipeline
+channels:
+  - conda-forge
+dependencies:
+  - python=3.11
+  - pip
+  - numpy
+  - pandas
+  - matplotlib
+  - pyyaml
+  - rdkit
+  - requests

libs/__init__.py

@@ -0,0 +1 @@
+"""Top-level package for modular docking pipeline libraries."""

libs/adaptive/__init__.py

@@ -0,0 +1,19 @@
+"""Adaptive scheduling, clustering, and surrogate learning components."""
+
+from .clustering import cluster_ligands_butina
+from .epsilon_regret import EpsilonRegretConfig, EpsilonRegretController
+from .hyperclustering import hypercluster_representatives
+from .scheduler import AdaptiveScheduler
+from .surrogate_model import SurrogateModel
+from .thresholding import DynamicEarlyStopController, DynamicThresholdConfig
+
+__all__ = [
+    "AdaptiveScheduler",
+    "DynamicEarlyStopController",
+    "DynamicThresholdConfig",
+    "EpsilonRegretConfig",
+    "EpsilonRegretController",
+    "SurrogateModel",
+    "cluster_ligands_butina",
+    "hypercluster_representatives",
+]

libs/adaptive/clustering.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Dict, Iterable, List, Sequence
+
+import numpy as np
+from rdkit import DataStructs
+from rdkit.Chem import rdchem
+from rdkit.ML.Cluster import Butina
+
+
+def _np_to_explicit_bitvect(fp: np.ndarray) -> DataStructs.ExplicitBitVect:
+    bitvect = DataStructs.ExplicitBitVect(fp.shape[0])
+    on_bits = np.where(fp > 0)[0]
+    for idx in on_bits:
+        bitvect.SetBit(int(idx))
+    return bitvect
+
+
+def cluster_ligands_butina(
+    ligand_ids: Sequence[str],
+    fingerprints: Sequence[np.ndarray],
+    cutoff: float = 0.35,
+) -> Dict[str, int]:
+    """Cluster ligands with Butina on Tanimoto distance over Morgan fingerprints."""
+    if not ligand_ids:
+        return {}
+    if len(ligand_ids) != len(fingerprints):
+        raise ValueError("ligand_ids and fingerprints must have same length")
+
+    fp_bv = [_np_to_explicit_bitvect(np.asarray(fp, dtype=int)) for fp in fingerprints]
+
+    dists: List[float] = []
+    for i in range(1, len(fp_bv)):
+        sims = DataStructs.BulkTanimotoSimilarity(fp_bv[i], fp_bv[:i])
+        dists.extend([1.0 - x for x in sims])
+
+    clusters = Butina.ClusterData(dists, len(fp_bv), cutoff, isDistData=True)
+
+    mapping: Dict[str, int] = {}
+    for c_idx, cluster in enumerate(clusters):
+        for member in cluster:
+            mapping[ligand_ids[member]] = c_idx
+
+    # Ensure all ligands map to a cluster, even edge cases.
+    for idx, ligand_id in enumerate(ligand_ids):
+        mapping.setdefault(ligand_id, max(mapping.values(), default=-1) + idx + 1)
+    return mapping

libs/adaptive/diversity.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+import numpy as np
+
+
+def _tanimoto(fp_a: np.ndarray, fp_b: np.ndarray) -> float:
+    inter = float(np.sum((fp_a > 0) & (fp_b > 0)))
+    union = float(np.sum((fp_a > 0) | (fp_b > 0)))
+    if union == 0:
+        return 0.0
+    return inter / union
+
+
+def selection_diversity(fingerprints: Iterable[np.ndarray]) -> float:
+    fps = list(fingerprints)
+    if len(fps) < 2:
+        return 0.0
+    distances = []
+    for i in range(len(fps)):
+        for j in range(i + 1, len(fps)):
+            distances.append(1.0 - _tanimoto(fps[i], fps[j]))
+    return float(np.mean(distances)) if distances else 0.0

libs/adaptive/epsilon_regret.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Sequence
+
+import numpy as np
+
+
+@dataclass
+class EpsilonRegretConfig:
+    epsilon_quality: float = 0.10
+    acceptable_regret: float = 0.10
+    min_budget: int = 250
+    max_budget: int = 10000
+    min_model_weight: float = 0.25
+    patience_rounds: int = 6
+    min_improvement: float = 0.02
+    uncertainty_multiplier: float = 0.50
+    min_cluster_coverage: float = 0.20
+    min_hypercluster_coverage: float = 0.20
+
+
+class EpsilonRegretController:
+    """
+    Budget-aware stop controller with epsilon-regret semantics.
+
+    Online intent:
+    stop when estimated remaining gain is small relative to current best score,
+    after minimum exploration and coverage constraints are satisfied.
+    """
+
+    def __init__(self, config: EpsilonRegretConfig | None = None) -> None:
+        self.config = config or EpsilonRegretConfig()
+        self.best_score = np.inf
+        self.stagnant_rounds = 0
+        self.history: List[Dict[str, float | int | bool | str]] = []
+
+    @staticmethod
+    def _mean_or_nan(values: Sequence[float]) -> float:
+        arr = np.asarray(values, dtype=float)
+        if arr.size == 0:
+            return float("nan")
+        return float(np.nanmean(arr))
+
+    @staticmethod
+    def _estimate_remaining_gain(
+        best_score: float,
+        expected_remaining_scores: Iterable[float],
+        uncertainty_scores: Iterable[float],
+        uncertainty_multiplier: float,
+    ) -> float:
+        pred = np.asarray(list(expected_remaining_scores), dtype=float)
+        unc = np.asarray(list(uncertainty_scores), dtype=float)
+        if pred.size == 0:
+            return float("inf")
+        if unc.size != pred.size:
+            unc = np.full(pred.shape[0], np.nanmean(unc) if unc.size else 1.0, dtype=float)
+        optimistic = pred - float(max(0.0, uncertainty_multiplier)) * np.abs(unc)
+        optimistic_best = float(np.nanmin(optimistic)) if np.isfinite(optimistic).any() else float(np.nanmin(pred))
+        if not np.isfinite(optimistic_best) or not np.isfinite(best_score):
+            return float("inf")
+        # lower score is better
+        return float(max(0.0, best_score - optimistic_best))
+
+    def update(
+        self,
+        *,
+        round_idx: int,
+        n_evaluated: int,
+        best_score_now: float,
+        recent_scores: Sequence[float],
+        model_weight: float,
+        cluster_coverage: float,
+        hypercluster_coverage: float,
+        expected_remaining_scores: Iterable[float],
+        uncertainty_scores: Iterable[float],
+        time_importance: float,
+        budget_cap: int,
+    ) -> Dict[str, float | int | bool | str]:
+        cfg = self.config
+        ti = float(max(0.0, min(1.0, float(time_importance))))
+
+        if np.isfinite(self.best_score):
+            improvement = float(self.best_score - best_score_now)
+        else:
+            improvement = float("inf")
+
+        if improvement > float(cfg.min_improvement):
+            self.stagnant_rounds = 0
+        else:
+            self.stagnant_rounds += 1
+        self.best_score = min(float(self.best_score), float(best_score_now))
+
+        epsilon_rel = float(max(cfg.epsilon_quality, cfg.acceptable_regret))
+        # Higher time importance permits slightly larger acceptable residual gain.
+        epsilon_rel *= float(1.0 + 0.5 * ti)
+        epsilon_abs = float(epsilon_rel * max(1.0, abs(float(self.best_score))))
+
+        remaining_gain = self._estimate_remaining_gain(
+            best_score=float(self.best_score),
+            expected_remaining_scores=expected_remaining_scores,
+            uncertainty_scores=uncertainty_scores,
+            uncertainty_multiplier=float(cfg.uncertainty_multiplier),
+        )
+        regret_ratio_proxy = float(remaining_gain / max(1.0, abs(float(self.best_score))))
+
+        budget_floor = int(max(1, cfg.min_budget))
+        budget_ceiling = int(min(cfg.max_budget, budget_cap))
+        budget_ready = int(n_evaluated) >= budget_floor
+        model_ready = float(model_weight) >= float(cfg.min_model_weight)
+        coverage_ready = bool(
+            float(cluster_coverage) >= float(cfg.min_cluster_coverage)
+            and float(hypercluster_coverage) >= float(cfg.min_hypercluster_coverage)
+        )
+        stagnation_ready = int(self.stagnant_rounds) >= int(cfg.patience_rounds)
+
+        hit_budget_ceiling = int(n_evaluated) >= int(budget_ceiling)
+        epsilon_ready = bool(np.isfinite(remaining_gain) and remaining_gain <= epsilon_abs)
+        stop = bool(hit_budget_ceiling or (budget_ready and model_ready and coverage_ready and stagnation_ready and epsilon_ready))
+
+        if hit_budget_ceiling:
+            reason = "max_budget_reached"
+        elif not budget_ready:
+            reason = "below_min_budget"
+        elif not model_ready:
+            reason = "model_not_ready"
+        elif not coverage_ready:
+            reason = "coverage_not_ready"
+        elif not stagnation_ready:
+            reason = "insufficient_stagnation_evidence"
+        elif not epsilon_ready:
+            reason = "remaining_gain_above_epsilon"
+        else:
+            reason = "epsilon_regret_stop"
+
+        rec = {
+            "round_idx": int(round_idx),
+            "n_evaluated": int(n_evaluated),
+            "best_score": float(self.best_score),
+            "recent_mean_score": self._mean_or_nan(recent_scores),
+            "model_weight": float(model_weight),
+            "cluster_coverage": float(cluster_coverage),
+            "hypercluster_coverage": float(hypercluster_coverage),
+            "stagnant_rounds": int(self.stagnant_rounds),
+            "epsilon_abs": float(epsilon_abs),
+            "estimated_remaining_gain": float(remaining_gain),
+            "regret_ratio_proxy": float(regret_ratio_proxy),
+            "budget_floor": int(budget_floor),
+            "budget_ceiling": int(budget_ceiling),
+            "budget_ready": bool(budget_ready),
+            "model_ready": bool(model_ready),
+            "coverage_ready": bool(coverage_ready),
+            "stagnation_ready": bool(stagnation_ready),
+            "epsilon_ready": bool(epsilon_ready),
+            "stop": bool(stop),
+            "reason": reason,
+        }
+        self.history.append(rec)
+        return rec
+

libs/adaptive/features.py

@@ -0,0 +1,408 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Tuple
+
+import numpy as np
+import pandas as pd
+from rdkit import Chem
+from rdkit.Chem import AllChem, Descriptors, Lipinski, MolSurf, rdMolDescriptors
+from rdkit.Chem.Scaffolds import MurckoScaffold
+from rdkit.DataStructs import TanimotoSimilarity
+
+try:
+    from rdkit.Chem import rdFreeSASA
+except Exception:  # pragma: no cover
+    rdFreeSASA = None  # type: ignore[assignment]
+
+
+@dataclass
+class FeatureValue:
+    value: float | None
+    available: bool
+    source: str
+    feature_type: str
+
+
+@dataclass
+class FeatureBundle:
+    object_id: str
+    features: Dict[str, FeatureValue]
+
+    def to_records(self, channel: str, round_idx: int | None = None) -> List[dict]:
+        rows: List[dict] = []
+        for name, fv in sorted(self.features.items()):
+            rows.append(
+                {
+                    "object_id": self.object_id,
+                    "round": round_idx,
+                    "channel": channel,
+                    "feature_name": name,
+                    "value": fv.value,
+                    "available": bool(fv.available),
+                    "source": fv.source,
+                    "feature_type": fv.feature_type,
+                }
+            )
+        return rows
+
+
+def _fv(value: float | None, available: bool, source: str, feature_type: str) -> FeatureValue:
+    return FeatureValue(value=value, available=available, source=source, feature_type=feature_type)
+
+
+def _safe_float(value: float | int | None) -> float | None:
+    if value is None:
+        return None
+    try:
+        v = float(value)
+    except Exception:
+        return None
+    if not np.isfinite(v):
+        return None
+    return v
+
+
+def _compute_ligand_sasa(mol: Chem.Mol) -> Tuple[float | None, bool]:
+    if rdFreeSASA is None:
+        return None, False
+    try:
+        if mol.GetNumConformers() == 0:
+            m = Chem.AddHs(Chem.Mol(mol))
+            status = AllChem.EmbedMolecule(m, AllChem.ETKDGv3())
+            if int(status) != 0:
+                return None, False
+        else:
+            m = Chem.Mol(mol)
+
+        if m.GetNumConformers() == 0:
+            return None, False
+
+        radii = rdFreeSASA.classifyAtoms(m)
+        sasa = rdFreeSASA.CalcSASA(m, radii)
+        return _safe_float(sasa), True
+    except Exception:
+        return None, False
+
+
+def build_ligand_feature_bundle(
+    ligand_id: str,
+    smiles: str,
+    fingerprint: np.ndarray,
+    reference_mol: Chem.Mol | None = None,
+    compute_partial_charges: bool = True,
+    compute_sasa: bool = True,
+) -> FeatureBundle:
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise ValueError(f"Invalid SMILES for ligand {ligand_id}: {smiles}")
+
+    m_h = Chem.AddHs(Chem.Mol(mol))
+    if compute_partial_charges:
+        try:
+            AllChem.ComputeGasteigerCharges(m_h)
+            partial_charges = []
+            for atom in m_h.GetAtoms():
+                prop = atom.GetProp("_GasteigerCharge") if atom.HasProp("_GasteigerCharge") else "nan"
+                try:
+                    q = float(prop)
+                except Exception:
+                    continue
+                if np.isfinite(q):
+                    partial_charges.append(q)
+            if partial_charges:
+                mean_abs_q = float(np.mean(np.abs(partial_charges)))
+                total_q = float(np.sum(partial_charges))
+                has_q = True
+            else:
+                mean_abs_q = None
+                total_q = None
+                has_q = False
+        except Exception:
+            mean_abs_q = None
+            total_q = None
+            has_q = False
+    else:
+        mean_abs_q = None
+        total_q = None
+        has_q = False
+
+    aromatic_rings = rdMolDescriptors.CalcNumAromaticRings(mol)
+    formal_charge = Chem.GetFormalCharge(mol)
+    heavy_atoms = mol.GetNumHeavyAtoms()
+    frac_csp3 = rdMolDescriptors.CalcFractionCSP3(mol)
+    bertz_ct = Descriptors.BertzCT(mol)
+    balaban_j = Descriptors.BalabanJ(mol)
+    topological_complexity = rdMolDescriptors.CalcChi0v(mol)
+
+    if compute_sasa:
+        ligand_sasa, has_sasa = _compute_ligand_sasa(m_h)
+    else:
+        ligand_sasa, has_sasa = None, False
+
+    reference_similarity = None
+    scaffold_match = None
+    chemical_distance = None
+    if reference_mol is not None:
+        fp_gen = AllChem.GetMorganGenerator(radius=2, fpSize=int(fingerprint.shape[0]))
+        ref_fp = fp_gen.GetFingerprint(reference_mol)
+        lig_fp = fp_gen.GetFingerprint(mol)
+        sim = TanimotoSimilarity(ref_fp, lig_fp)
+        reference_similarity = float(sim)
+        chemical_distance = float(1.0 - sim)
+
+        ref_scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=reference_mol)
+        lig_scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol)
+        scaffold_match = float(ref_scaffold == lig_scaffold)
+
+    features: Dict[str, FeatureValue] = {
+        "ligand_mw": _fv(_safe_float(Descriptors.MolWt(mol)), True, "rdkit", "exact"),
+        "ligand_logp": _fv(_safe_float(Descriptors.MolLogP(mol)), True, "rdkit", "exact"),
+        "ligand_tpsa": _fv(_safe_float(MolSurf.TPSA(mol)), True, "rdkit", "exact"),
+        "ligand_hbd": _fv(_safe_float(Lipinski.NumHDonors(mol)), True, "rdkit", "exact"),
+        "ligand_hba": _fv(_safe_float(Lipinski.NumHAcceptors(mol)), True, "rdkit", "exact"),
+        "ligand_rotatable_bonds": _fv(_safe_float(Lipinski.NumRotatableBonds(mol)), True, "rdkit", "exact"),
+        "ligand_aromatic_ring_count": _fv(_safe_float(aromatic_rings), True, "rdkit", "exact"),
+        "ligand_formal_charge": _fv(_safe_float(formal_charge), True, "rdkit", "exact"),
+        "ligand_partial_charge_abs_mean": _fv(mean_abs_q, has_q, "rdkit", "approximate"),
+        "ligand_partial_charge_total": _fv(total_q, has_q, "rdkit", "approximate"),
+        "ligand_topological_bertz": _fv(_safe_float(bertz_ct), True, "rdkit", "exact"),
+        "ligand_topological_balaban_j": _fv(_safe_float(balaban_j), True, "rdkit", "exact"),
+        "ligand_topological_chi0v": _fv(_safe_float(topological_complexity), True, "rdkit", "exact"),
+        "ligand_fraction_csp3": _fv(_safe_float(frac_csp3), True, "rdkit", "exact"),
+        "ligand_heavy_atom_count": _fv(_safe_float(heavy_atoms), True, "rdkit", "exact"),
+        "ligand_sasa": _fv(ligand_sasa, has_sasa, "geometric", "approximate"),
+        "similarity_to_reference": _fv(reference_similarity, reference_similarity is not None, "rdkit", "exact"),
+        "scaffold_match": _fv(scaffold_match, scaffold_match is not None, "rdkit", "exact"),
+        "chemical_distance_to_reference": _fv(chemical_distance, chemical_distance is not None, "rdkit", "exact"),
+    }
+
+    for i, bit in enumerate(fingerprint.astype(float).tolist()):
+        features[f"morgan_fp_{i:04d}"] = _fv(float(bit), True, "rdkit", "exact")
+
+    return FeatureBundle(object_id=ligand_id, features=features)
+
+
+def build_protein_feature_bundle(target_id: str, sequence_features: Dict[str, float], structure_features: Dict[str, float]) -> FeatureBundle:
+    seq_len = float(sequence_features.get("seq_length", 1.0) or 1.0)
+    hydrophobic = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["A", "V", "I", "L", "M", "F", "W", "Y"])
+    charged = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["K", "R", "H", "D", "E"])
+    polar = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["S", "T", "N", "Q", "C"])
+
+    residue_count = float(structure_features.get("residue_count", 0.0))
+    mean_extent = float(structure_features.get("mean_spatial_extent", 0.0))
+    pocket_residues = float(structure_features.get("pocket_residue_count", 0.0))
+
+    approx_volume = float(max(0.0, mean_extent**3))
+    pocket_coverage = float(pocket_residues / max(residue_count, 1.0))
+
+    features = {
+        "pocket_hydrophobic_fraction": _fv(hydrophobic, True, "protein", "exact"),
+        "pocket_charged_fraction": _fv(charged, True, "protein", "exact"),
+        "pocket_polar_fraction": _fv(polar, True, "protein", "exact"),
+        "pocket_residue_count": _fv(residue_count, True, "protein", "exact"),
+        "pocket_volume_approx": _fv(approx_volume, True, "geometric", "approximate"),
+        "pocket_coverage_fraction": _fv(pocket_coverage, True, "geometric", "approximate"),
+        "pocket_sequence_length": _fv(seq_len, True, "protein", "exact"),
+    }
+    return FeatureBundle(object_id=target_id, features=features)
+
+
+def build_complex_feature_bundle(
+    ligand_id: str,
+    docking_score: float,
+    interface_features: Dict[str, float],
+    ligand_bundle: FeatureBundle,
+    protein_bundle: FeatureBundle,
+) -> FeatureBundle:
+    lig = ligand_bundle.features
+    prot = protein_bundle.features
+
+    logp = lig.get("ligand_logp", _fv(None, False, "rdkit", "exact")).value or 0.0
+    tpsa = lig.get("ligand_tpsa", _fv(None, False, "rdkit", "exact")).value or 0.0
+    charge_mag = lig.get("ligand_partial_charge_abs_mean", _fv(None, False, "rdkit", "approximate")).value
+    heavy_atoms = lig.get("ligand_heavy_atom_count", _fv(None, False, "rdkit", "exact")).value or 1.0
+    pocket_volume = prot.get("pocket_volume_approx", _fv(None, False, "geometric", "approximate")).value or 1.0
+    pocket_hydrophobic = prot.get("pocket_hydrophobic_fraction", _fv(None, False, "protein", "exact")).value or 0.0
+
+    interface_contact_proxy = float(interface_features.get("interface_contact_proxy", max(0.0, -docking_score / 8.0)))
+    hbond_proxy = float(interface_features.get("hbond_proxy", max(0.0, tpsa / 100.0)))
+    shape_proxy = float(interface_features.get("shape_proxy", max(0.0, 1.0 / (1.0 + abs(docking_score)))))
+
+    contact_count = max(1.0, heavy_atoms * (0.3 + interface_contact_proxy))
+    polar_contacts = contact_count * min(1.0, tpsa / 120.0)
+    hydrophobic_contacts = contact_count * min(1.0, max(0.0, logp) / 6.0) * (0.5 + pocket_hydrophobic)
+    clash_count = max(0.0, docking_score - 9.0)
+    min_distance = max(1.5, 6.0 - interface_contact_proxy)
+    pocket_coverage = min(1.0, contact_count / max(10.0, pocket_volume / 20.0))
+    interaction_density = contact_count / max(1.0, pocket_volume)
+
+    ligand_sasa = lig.get("ligand_sasa", _fv(None, False, "geometric", "approximate")).value
+    protein_sasa = pocket_volume * 0.75
+    if ligand_sasa is not None:
+        complex_sasa = max(1.0, protein_sasa + ligand_sasa - 0.5 * contact_count)
+        buried_sasa = max(0.0, protein_sasa + ligand_sasa - complex_sasa)
+        burial_ratio = buried_sasa / max(ligand_sasa, 1e-6)
+        sasa_available = True
+    else:
+        complex_sasa = None
+        buried_sasa = None
+        burial_ratio = None
+        sasa_available = False
+
+    if charge_mag is not None:
+        electrostatic_proxy = -charge_mag * max(0.5, 5.0 - min_distance)
+        electro_available = True
+    else:
+        electrostatic_proxy = None
+        electro_available = False
+
+    contact_energy = -0.15 * contact_count
+    steric_penalty = 0.6 * clash_count
+    hydrophobic_proxy = -0.1 * hydrophobic_contacts
+    interaction_decomp = contact_energy + hydrophobic_proxy + (electrostatic_proxy or 0.0) + steric_penalty
+
+    features = {
+        "complex_contact_count": _fv(float(contact_count), True, "interaction", "proxy"),
+        "complex_hbond_proxy": _fv(float(hbond_proxy), True, "interaction", "proxy"),
+        "complex_polar_contact_count": _fv(float(polar_contacts), True, "interaction", "proxy"),
+        "complex_hydrophobic_contact_proxy": _fv(float(hydrophobic_contacts), True, "interaction", "proxy"),
+        "complex_clash_count": _fv(float(clash_count), True, "interaction", "proxy"),
+        "complex_min_distance": _fv(float(min_distance), True, "geometric", "approximate"),
+        "complex_pocket_coverage": _fv(float(pocket_coverage), True, "interaction", "proxy"),
+        "complex_interaction_density": _fv(float(interaction_density), True, "interaction", "proxy"),
+        "complex_ligand_sasa": _fv(_safe_float(ligand_sasa), ligand_sasa is not None, "geometric", "approximate"),
+        "complex_protein_sasa": _fv(_safe_float(protein_sasa), True, "geometric", "approximate"),
+        "complex_sasa": _fv(_safe_float(complex_sasa), sasa_available, "geometric", "approximate"),
+        "complex_buried_sasa": _fv(_safe_float(buried_sasa), sasa_available, "geometric", "approximate"),
+        "complex_shape_complementarity": _fv(float(shape_proxy), True, "geometric", "proxy"),
+        "complex_ligand_burial_ratio": _fv(_safe_float(burial_ratio), sasa_available, "geometric", "approximate"),
+        "energy_contact_proxy": _fv(float(contact_energy), True, "energy_proxy", "proxy"),
+        "energy_electrostatic_proxy": _fv(_safe_float(electrostatic_proxy), electro_available, "energy_proxy", "proxy"),
+        "energy_steric_clash_penalty": _fv(float(steric_penalty), True, "energy_proxy", "proxy"),
+        "energy_hydrophobic_proxy": _fv(float(hydrophobic_proxy), True, "energy_proxy", "proxy"),
+        "energy_interaction_decomposition": _fv(float(interaction_decomp), True, "energy_proxy", "proxy"),
+    }
+
+    return FeatureBundle(object_id=ligand_id, features=features)
+
+
+def build_rdock_feature_bundle(
+    ligand_id: str,
+    parsed_row: Dict[str, float | int | str | bool | None],
+) -> FeatureBundle:
+    """Build a feature bundle from rDock-native and rDock-derived per-ligand outputs."""
+
+    def _as_feature(
+        key: str,
+        source: str,
+        ftype: str,
+    ) -> FeatureValue:
+        value = _safe_float(parsed_row.get(key))  # type: ignore[arg-type]
+        return _fv(value, value is not None, source, ftype if value is not None else "unavailable")
+
+    features: Dict[str, FeatureValue] = {
+        "rdock_total_score": _as_feature("rdock_total_score", "rdock_native", "exact"),
+        "rdock_pose_rank": _as_feature("rdock_pose_rank", "rdock_native", "exact"),
+        "n_generated_poses": _as_feature("n_generated_poses", "rdock_native", "exact"),
+        "best_pose_score": _as_feature("best_pose_score", "rdock_native", "exact"),
+        "mean_top3_pose_score": _as_feature("mean_top3_pose_score", "rdock_native", "exact"),
+        "mean_top5_pose_score": _as_feature("mean_top5_pose_score", "rdock_native", "exact"),
+        "std_top5_pose_score": _as_feature("std_top5_pose_score", "rdock_native", "exact"),
+        "pose_score_gap_1_2": _as_feature("pose_score_gap_1_2", "rdock_native", "exact"),
+        "rdock_restraint_term": _as_feature("rdock_restraint_term", "rdock_native", "exact"),
+        "rdock_internal_ligand_term": _as_feature("rdock_internal_ligand_term", "rdock_native", "exact"),
+        "rdock_polar_term": _as_feature("rdock_polar_term", "rdock_native", "exact"),
+        "rdock_vdw_term": _as_feature("rdock_vdw_term", "rdock_native", "exact"),
+        "top_pose_rmsd_consistency": _as_feature("top_pose_rmsd_consistency", "rdock_derived", "proxy"),
+        "contact_overlap_consistency": _as_feature("contact_overlap_consistency", "rdock_derived", "proxy"),
+        "hotspot_contact_frequency": _as_feature("hotspot_contact_frequency", "rdock_derived", "proxy"),
+        "subpocket_match_score": _as_feature("subpocket_match_score", "rdock_derived", "proxy"),
+        "replicate_mean_score": _as_feature("replicate_mean_score", "rdock_derived", "proxy"),
+        "replicate_score_variance": _as_feature("replicate_score_variance", "rdock_derived", "proxy"),
+        "replicate_consensus_score": _as_feature("replicate_consensus_score", "rdock_derived", "proxy"),
+    }
+    return FeatureBundle(object_id=ligand_id, features=features)
+
+
+def merge_bundles(object_id: str, bundles: Iterable[FeatureBundle]) -> FeatureBundle:
+    merged: Dict[str, FeatureValue] = {}
+    for bundle in bundles:
+        merged.update(bundle.features)
+    return FeatureBundle(object_id=object_id, features=merged)
+
+
+def bundles_to_wide_frames(
+    bundles: List[FeatureBundle],
+    ordered_feature_names: List[str] | None = None,
+) -> Tuple[pd.DataFrame, pd.DataFrame, List[str]]:
+    if not bundles:
+        return pd.DataFrame(), pd.DataFrame(), []
+
+    if ordered_feature_names is None:
+        feature_set = set()
+        for bundle in bundles:
+            feature_set.update(bundle.features.keys())
+        ordered_feature_names = sorted(feature_set)
+
+    value_rows = []
+    mask_rows = []
+    for bundle in bundles:
+        vrow = {"ligand_id": bundle.object_id}
+        mrow = {"ligand_id": bundle.object_id}
+        for name in ordered_feature_names:
+            fv = bundle.features.get(name)
+            if fv is None or not fv.available or fv.value is None:
+                vrow[name] = np.nan
+                mrow[f"mask_{name}"] = 0
+            else:
+                vrow[name] = float(fv.value)
+                mrow[f"mask_{name}"] = 1
+        value_rows.append(vrow)
+        mask_rows.append(mrow)
+
+    return pd.DataFrame(value_rows), pd.DataFrame(mask_rows), ordered_feature_names
+
+
+def compute_feature_diagnostics(values_df: pd.DataFrame, masks_df: pd.DataFrame, target: pd.Series | None = None) -> pd.DataFrame:
+    if values_df.empty:
+        return pd.DataFrame(columns=["feature", "missing_frac", "mean", "std", "min", "max", "is_constant", "corr_to_target"])
+
+    numeric_cols = [c for c in values_df.columns if c != "ligand_id"]
+    rows = []
+    for col in numeric_cols:
+        vals = pd.to_numeric(values_df[col], errors="coerce")
+        mask_col = f"mask_{col}"
+        if mask_col in masks_df.columns:
+            missing_frac = 1.0 - float(pd.to_numeric(masks_df[mask_col], errors="coerce").mean())
+        else:
+            missing_frac = float(vals.isna().mean())
+
+        finite_vals = vals[np.isfinite(vals)]
+        is_constant = finite_vals.nunique(dropna=True) <= 1 if not finite_vals.empty else True
+
+        if target is not None and len(target) == len(vals):
+            target_num = pd.to_numeric(target, errors="coerce")
+            paired = pd.concat([vals, target_num], axis=1).dropna()
+            if paired.shape[0] >= 3 and paired.iloc[:, 0].nunique(dropna=True) > 1 and paired.iloc[:, 1].nunique(dropna=True) > 1:
+                corr = paired.iloc[:, 0].corr(paired.iloc[:, 1])
+                corr_val = float(corr) if corr is not None and np.isfinite(corr) else np.nan
+            else:
+                corr_val = np.nan
+        else:
+            corr_val = np.nan
+
+        rows.append(
+            {
+                "feature": col,
+                "missing_frac": float(missing_frac),
+                "mean": float(finite_vals.mean()) if not finite_vals.empty else np.nan,
+                "std": float(finite_vals.std()) if not finite_vals.empty else np.nan,
+                "min": float(finite_vals.min()) if not finite_vals.empty else np.nan,
+                "max": float(finite_vals.max()) if not finite_vals.empty else np.nan,
+                "is_constant": bool(is_constant),
+                "corr_to_target": corr_val,
+            }
+        )
+
+    return pd.DataFrame(rows).sort_values(["missing_frac", "feature"], ascending=[False, True]).reset_index(drop=True)

libs/adaptive/hyperclustering.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Dict, Sequence
+
+import numpy as np
+from sklearn.cluster import AgglomerativeClustering
+
+
+def hypercluster_representatives(
+    cluster_vectors: Dict[int, np.ndarray],
+    n_hyperclusters: int | None = None,
+) -> Dict[int, int]:
+    """Agglomerative clustering over cluster representative vectors."""
+    if not cluster_vectors:
+        return {}
+
+    cluster_ids = sorted(cluster_vectors)
+    x = np.vstack([cluster_vectors[cid] for cid in cluster_ids])
+
+    if len(cluster_ids) == 1:
+        return {cluster_ids[0]: 0}
+
+    n_clusters = n_hyperclusters or max(2, int(np.sqrt(len(cluster_ids))))
+    n_clusters = min(n_clusters, len(cluster_ids))
+
+    model = AgglomerativeClustering(n_clusters=n_clusters)
+    labels = model.fit_predict(x)
+    return {cluster_id: int(label) for cluster_id, label in zip(cluster_ids, labels)}

libs/adaptive/metrics.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Dict, Iterable, Sequence
+
+import numpy as np
+
+from .diversity import selection_diversity
+
+
+def clustering_metrics(cluster_map: Dict[str, int], hypercluster_map: Dict[int, int]) -> Dict[str, float]:
+    return {
+        "ligand_count": float(len(cluster_map)),
+        "cluster_count": float(len(set(cluster_map.values())) if cluster_map else 0),
+        "hypercluster_count": float(len(set(hypercluster_map.values())) if hypercluster_map else 0),
+    }
+
+
+def score_metrics(scores: Sequence[float]) -> Dict[str, float]:
+    if not scores:
+        return {
+            "evaluated_ligand_count": 0.0,
+            "mean_score": 0.0,
+            "best_score": 0.0,
+        }
+    arr = np.asarray(scores, dtype=float)
+    return {
+        "evaluated_ligand_count": float(arr.size),
+        "mean_score": float(np.mean(arr)),
+        "best_score": float(np.min(arr)),
+    }
+
+
+def enrichment_metrics(scores: Sequence[float], labels: Sequence[int] | None, topk: int = 10) -> Dict[str, float]:
+    if labels is None or not scores or len(labels) != len(scores):
+        return {"topk_hit_rate": 0.0, "enrichment_like": 0.0}
+
+    idx_sorted = np.argsort(np.asarray(scores, dtype=float))
+    labels_arr = np.asarray(labels, dtype=int)
+    k = min(topk, len(idx_sorted))
+    top_hits = int(np.sum(labels_arr[idx_sorted[:k]]))
+    baseline = float(np.mean(labels_arr)) if labels_arr.size else 0.0
+    hit_rate = top_hits / max(k, 1)
+    enrichment = (hit_rate / baseline) if baseline > 0 else 0.0
+    return {"topk_hit_rate": float(hit_rate), "enrichment_like": float(enrichment)}
+
+
+def diversity_metric(selected_fingerprints: Iterable[np.ndarray]) -> Dict[str, float]:
+    return {"selection_diversity": selection_diversity(selected_fingerprints)}

libs/adaptive/policies.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class PrioritizationPolicy:
+    utility_weight: float = 0.55
+    uncertainty_weight: float = 0.2
+    diversity_weight: float = 0.15
+    cluster_bonus_weight: float = 0.1
+    conservative_deprioritize_quantile: float = 0.15

libs/adaptive/prioritization.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from .policies import PrioritizationPolicy
+
+
+def compute_priority(
+    predicted_utility: float,
+    uncertainty: float,
+    diversity_gain: float,
+    cluster_bonus: float,
+    policy: PrioritizationPolicy,
+) -> float:
+    """Weighted priority function used by adaptive queueing."""
+    return (
+        policy.utility_weight * predicted_utility
+        + policy.uncertainty_weight * uncertainty
+        + policy.diversity_weight * diversity_gain
+        + policy.cluster_bonus_weight * cluster_bonus
+    )
+
+
+def cluster_bonus(cluster_load: Dict[int, int], cluster_id: int) -> float:
+    load = cluster_load.get(cluster_id, 0)
+    return 1.0 / (1.0 + float(load))

libs/adaptive/queue_manager.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Iterable, List
+
+from .state import QueueItem
+
+VALID_STATUSES = {"active", "deprioritized", "frozen", "completed"}
+
+
+@dataclass
+class QueueManager:
+    items: Dict[str, QueueItem]
+
+    @classmethod
+    def from_items(cls, items: Iterable[QueueItem]) -> "QueueManager":
+        return cls(items={item.ligand_id: item for item in items})
+
+    def set_status(self, ligand_id: str, status: str) -> None:
+        if status not in VALID_STATUSES:
+            raise ValueError(f"Invalid status: {status}")
+        self.items[ligand_id].status = status
+
+    def active_items(self) -> List[QueueItem]:
+        return [item for item in self.items.values() if item.status == "active"]
+
+    def completed_items(self) -> List[QueueItem]:
+        return [item for item in self.items.values() if item.status == "completed"]
+
+    def ordered_active(self) -> List[QueueItem]:
+        return sorted(self.active_items(), key=lambda item: item.priority, reverse=True)

libs/adaptive/scheduler.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List
+
+import numpy as np
+import pandas as pd
+
+from .metrics import score_metrics
+from .policies import PrioritizationPolicy
+from .prioritization import cluster_bonus, compute_priority
+from .queue_manager import QueueManager
+from .state import QueueItem, SchedulerState
+from .surrogate_model import SurrogateConfig, SurrogateModel
+from .weight_schedule import WeightScheduleConfig, compute_model_weight
+
+
+@dataclass
+class SchedulerConfig:
+    batch_size: int = 8
+    init_coverage_fraction: float = 0.25
+    conservative_deprioritize: bool = True
+    state_path: str = "results/state.json"
+    weight_schedule: WeightScheduleConfig = field(default_factory=WeightScheduleConfig)
+
+
+class AdaptiveScheduler:
+    """Adaptive batch scheduler with queue state and online masked surrogate updates."""
+
+    def __init__(
+        self,
+        config: SchedulerConfig | None = None,
+        policy: PrioritizationPolicy | None = None,
+        surrogate_config: SurrogateConfig | None = None,
+    ) -> None:
+        self.config = config or SchedulerConfig()
+        self.policy = policy or PrioritizationPolicy()
+        self.surrogate = SurrogateModel(surrogate_config)
+        self.state = SchedulerState()
+        self.queue_manager = QueueManager.from_items([])
+        self.last_model_weight: float = 0.0
+
+    def initialize(
+        self,
+        ligands_df: pd.DataFrame,
+        cluster_map: Dict[str, int],
+        hypercluster_for_cluster: Dict[int, int],
+    ) -> None:
+        items: List[QueueItem] = []
+        cluster_load: Dict[int, int] = {}
+
+        for row in ligands_df.itertuples(index=False):
+            ligand_id = str(row.ligand_id)
+            cluster_id = int(cluster_map.get(ligand_id, -1))
+            hypercluster_id = int(hypercluster_for_cluster.get(cluster_id, -1))
+            bonus = cluster_bonus(cluster_load, cluster_id)
+            priority = compute_priority(
+                predicted_utility=0.0,
+                uncertainty=1.0,
+                diversity_gain=bonus,
+                cluster_bonus=bonus,
+                policy=self.policy,
+            )
+            items.append(
+                QueueItem(
+                    ligand_id=ligand_id,
+                    status="active",
+                    priority=float(priority),
+                    cluster_id=cluster_id,
+                    hypercluster_id=hypercluster_id,
+                )
+            )
+            cluster_load[cluster_id] = cluster_load.get(cluster_id, 0) + 1
+
+        self.state = SchedulerState(queue=items, batch_history=[], round_idx=0)
+        self.queue_manager = QueueManager.from_items(items)
+
+    def select_batch(self) -> List[str]:
+        active = self.queue_manager.ordered_active()
+        if not active:
+            # If conservative deprioritization exhausted active queue, reactivate
+            # deprioritized candidates to continue spending the docking budget.
+            deprioritized = sorted(
+                [item for item in self.queue_manager.items.values() if item.status == "deprioritized"],
+                key=lambda item: item.priority,
+                reverse=True,
+            )
+            if not deprioritized:
+                return []
+            for item in deprioritized:
+                item.status = "active"
+            active = deprioritized
+
+        coverage_count = max(1, int(self.config.batch_size * self.config.init_coverage_fraction))
+        by_hypercluster: Dict[int, List[QueueItem]] = {}
+        for item in active:
+            by_hypercluster.setdefault(item.hypercluster_id, []).append(item)
+
+        selected: List[str] = []
+        # Broad initial coverage.
+        for _h_id, items in sorted(by_hypercluster.items(), key=lambda x: len(x[1]), reverse=True):
+            if len(selected) >= coverage_count:
+                break
+            selected.append(items[0].ligand_id)
+
+        # Fill remaining slots by priority.
+        for item in active:
+            if len(selected) >= self.config.batch_size:
+                break
+            if item.ligand_id not in selected:
+                selected.append(item.ligand_id)
+
+        for ligand_id in selected:
+            self.queue_manager.items[ligand_id].times_selected += 1
+        return selected
+
+    @staticmethod
+    def _mean_or_default(values: list[float], default: float = 0.0) -> float:
+        if not values:
+            return float(default)
+        return float(np.mean(np.asarray(values, dtype=float)))
+
+    def update_from_batch(
+        self,
+        evaluated_df: pd.DataFrame,
+        feature_values_df: pd.DataFrame,
+        feature_masks_df: pd.DataFrame,
+    ) -> Dict[str, float]:
+        # Mark completed ligands and store latest score.
+        score_map = dict(zip(evaluated_df["ligand_id"].astype(str), evaluated_df["docking_score"].astype(float)))
+        for ligand_id, score in score_map.items():
+            if ligand_id in self.queue_manager.items:
+                item = self.queue_manager.items[ligand_id]
+                item.status = "completed"
+                item.last_score = float(score)
+
+        if feature_values_df.empty or feature_masks_df.empty:
+            raise ValueError("Feature tables cannot be empty in adaptive update")
+
+        if "ligand_id" not in feature_values_df.columns or "ligand_id" not in feature_masks_df.columns:
+            raise ValueError("Feature tables must include ligand_id column")
+
+        ligand_order = feature_values_df["ligand_id"].astype(str).tolist()
+        features = feature_values_df.drop(columns=["ligand_id"]).to_numpy(dtype=float)
+        masks = feature_masks_df.drop(columns=["ligand_id"]).to_numpy(dtype=float)
+        feature_names = feature_values_df.drop(columns=["ligand_id"]).columns.tolist()
+        mask_names = feature_masks_df.drop(columns=["ligand_id"]).columns.tolist()
+
+        target = np.full(len(ligand_order), np.nan, dtype=float)
+        for i, ligand_id in enumerate(ligand_order):
+            if ligand_id in self.queue_manager.items:
+                score = self.queue_manager.items[ligand_id].last_score
+                if score is not None:
+                    target[i] = float(score)
+
+        fit_stats = self.surrogate.fit(
+            features=features,
+            masks=masks,
+            y=target,
+            feature_names=feature_names,
+            mask_names=mask_names,
+        )
+
+        n_train = int(fit_stats.get("n_train", 0.0))
+        instability_ratio = float(fit_stats.get("instability_ratio", 1.0))
+        model_weight = compute_model_weight(
+            n_samples=n_train,
+            instability_ratio=instability_ratio,
+            config=self.config.weight_schedule,
+        )
+        if self.surrogate.model is None:
+            model_weight = 0.0
+        self.last_model_weight = float(model_weight)
+
+        # Predict for active items.
+        active_items = self.queue_manager.active_items()
+        active_ids = [item.ligand_id for item in active_items]
+
+        completed_items = [item for item in self.queue_manager.items.values() if item.last_score is not None]
+        global_completed = [float(item.last_score) for item in completed_items if item.last_score is not None]
+        global_mean_score = self._mean_or_default(global_completed, default=0.0)
+
+        cluster_scores: Dict[int, list[float]] = {}
+        hyper_scores: Dict[int, list[float]] = {}
+        for item in completed_items:
+            assert item.last_score is not None
+            cluster_scores.setdefault(item.cluster_id, []).append(float(item.last_score))
+            hyper_scores.setdefault(item.hypercluster_id, []).append(float(item.last_score))
+
+        if active_ids:
+            id_to_idx = {lid: idx for idx, lid in enumerate(ligand_order)}
+            x_active = np.vstack([features[id_to_idx[lid]] for lid in active_ids])
+            m_active = np.vstack([masks[id_to_idx[lid]] for lid in active_ids])
+            bundle = self.surrogate.predict_bundle(x_active, m_active)
+
+            cluster_load: Dict[int, int] = {}
+            for item in active_items:
+                cluster_load[item.cluster_id] = cluster_load.get(item.cluster_id, 0) + 1
+
+            for i, ligand_id in enumerate(active_ids):
+                item = self.queue_manager.items[ligand_id]
+
+                cluster_mean = self._mean_or_default(cluster_scores.get(item.cluster_id, []), default=np.nan)
+                hyper_mean = self._mean_or_default(hyper_scores.get(item.hypercluster_id, []), default=np.nan)
+                observed_docking = (
+                    cluster_mean
+                    if np.isfinite(cluster_mean)
+                    else hyper_mean
+                    if np.isfinite(hyper_mean)
+                    else global_mean_score
+                )
+
+                docking_component = -float(observed_docking)
+                model_component = -float(bundle["expected_score"][i])
+                blended_utility = (1.0 - model_weight) * docking_component + model_weight * model_component
+
+                bonus = cluster_bonus(cluster_load, item.cluster_id)
+                item.priority = compute_priority(
+                    predicted_utility=float(blended_utility),
+                    uncertainty=float(bundle["uncertainty"][i]),
+                    diversity_gain=bonus,
+                    cluster_bonus=bonus,
+                    policy=self.policy,
+                )
+
+            if self.config.conservative_deprioritize:
+                priorities = np.asarray([self.queue_manager.items[lid].priority for lid in active_ids], dtype=float)
+                threshold = float(np.quantile(priorities, self.policy.conservative_deprioritize_quantile))
+                for lid in active_ids:
+                    if self.queue_manager.items[lid].priority < threshold:
+                        self.queue_manager.items[lid].status = "deprioritized"
+
+        self.state.round_idx += 1
+        sm = score_metrics(evaluated_df["docking_score"].astype(float).tolist())
+        batch_record: Dict[str, float | str] = {
+            "round_idx": self.state.round_idx,
+            "batch_size": int(evaluated_df.shape[0]),
+            "model_weight": float(model_weight),
+            "n_train": float(n_train),
+            "train_mae": float(fit_stats.get("train_mae", np.nan)),
+            "val_mae": float(fit_stats.get("val_mae", np.nan)),
+            "instability_ratio": float(instability_ratio),
+            "surrogate_backend": self.surrogate.backend,
+            **sm,
+        }
+        self.state.batch_history.append(batch_record)
+        return fit_stats
+
+    def save_state(self, output_path: str | Path | None = None) -> Path:
+        target = Path(output_path or self.config.state_path)
+        self.state.queue = list(self.queue_manager.items.values())
+        return self.state.save(target)

libs/adaptive/state.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List
+
+import json
+
+
+@dataclass
+class QueueItem:
+    ligand_id: str
+    status: str = "active"
+    priority: float = 0.0
+    hypercluster_id: int = -1
+    cluster_id: int = -1
+    times_selected: int = 0
+    last_score: float | None = None
+
+
+@dataclass
+class SchedulerState:
+    queue: List[QueueItem] = field(default_factory=list)
+    batch_history: List[Dict[str, Any]] = field(default_factory=list)
+    round_idx: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "queue": [asdict(item) for item in self.queue],
+            "batch_history": self.batch_history,
+            "round_idx": self.round_idx,
+        }
+
+    @classmethod
+    def from_dict(cls, payload: Dict[str, Any]) -> "SchedulerState":
+        queue = [QueueItem(**item) for item in payload.get("queue", [])]
+        return cls(queue=queue, batch_history=payload.get("batch_history", []), round_idx=int(payload.get("round_idx", 0)))
+
+    def save(self, path: str | Path) -> Path:
+        target = Path(path)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with target.open("w", encoding="utf-8") as handle:
+            json.dump(self.to_dict(), handle, indent=2)
+        return target
+
+    @classmethod
+    def load(cls, path: str | Path) -> "SchedulerState":
+        source = Path(path)
+        with source.open("r", encoding="utf-8") as handle:
+            return cls.from_dict(json.load(handle))

libs/adaptive/surrogate_model.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+import numpy as np
+from sklearn.ensemble import RandomForestRegressor
+
+try:
+    from xgboost import XGBRegressor
+except Exception:  # pragma: no cover
+    XGBRegressor = None  # type: ignore[assignment]
+
+
+@dataclass
+class SurrogateConfig:
+    prefer_xgboost: bool = True
+    random_state: int = 42
+    n_estimators: int = 200
+    min_train_samples: int = 8
+    max_depth_small: int = 3
+    max_depth_large: int = 6
+
+
+class SurrogateModel:
+    """Surrogate model with explicit missing-feature masking support."""
+
+    def __init__(self, config: Optional[SurrogateConfig] = None):
+        self.config = config or SurrogateConfig()
+        self.model = None
+        self.backend = "uninitialized"
+        self.feature_names: List[str] = []
+        self.mask_names: List[str] = []
+
+        self._median: np.ndarray | None = None
+        self._iqr: np.ndarray | None = None
+        self._train_x: np.ndarray | None = None
+        self._train_y: np.ndarray | None = None
+        self.last_fit_stats: Dict[str, float] = {}
+
+    def _build_model(self, n_samples: int):
+        max_depth = self.config.max_depth_small if n_samples < 50 else self.config.max_depth_large
+        if self.config.prefer_xgboost and XGBRegressor is not None:
+            self.backend = "xgboost"
+            return XGBRegressor(
+                n_estimators=self.config.n_estimators,
+                max_depth=max_depth,
+                learning_rate=0.05,
+                subsample=0.9,
+                colsample_bytree=0.9,
+                reg_alpha=0.1,
+                reg_lambda=1.0,
+                random_state=self.config.random_state,
+            )
+
+        self.backend = "random_forest"
+        return RandomForestRegressor(
+            n_estimators=max(100, self.config.n_estimators),
+            max_depth=max_depth,
+            random_state=self.config.random_state,
+            n_jobs=-1,
+        )
+
+    def _fit_normalizer(self, x: np.ndarray, m: np.ndarray) -> None:
+        med = []
+        iqr = []
+        for j in range(x.shape[1]):
+            vals = x[m[:, j] > 0.5, j]
+            if vals.size == 0:
+                med.append(0.0)
+                iqr.append(1.0)
+                continue
+            q1 = float(np.quantile(vals, 0.25))
+            q3 = float(np.quantile(vals, 0.75))
+            inter = max(1e-6, q3 - q1)
+            med.append(float(np.median(vals)))
+            iqr.append(inter)
+        self._median = np.asarray(med, dtype=float)
+        self._iqr = np.asarray(iqr, dtype=float)
+
+    def _transform(self, x: np.ndarray, m: np.ndarray, fit: bool = False) -> np.ndarray:
+        x = np.asarray(x, dtype=float)
+        m = np.asarray(m, dtype=float)
+        if fit or self._median is None or self._iqr is None:
+            self._fit_normalizer(x, m)
+        assert self._median is not None and self._iqr is not None
+
+        x_filled = np.where(np.isfinite(x), x, np.nan)
+        for j in range(x.shape[1]):
+            col = x_filled[:, j]
+            missing = ~np.isfinite(col)
+            col[missing] = self._median[j]
+            x_filled[:, j] = (col - self._median[j]) / self._iqr[j]
+
+        # Explicit missingness information: concatenate mask vector.
+        return np.concatenate([x_filled, m], axis=1)
+
+    def fit(
+        self,
+        features: np.ndarray,
+        masks: np.ndarray,
+        y: np.ndarray,
+        feature_names: List[str],
+        mask_names: List[str],
+    ) -> Dict[str, float]:
+        y = np.asarray(y, dtype=float)
+        valid = np.isfinite(y)
+        n_samples = int(np.sum(valid))
+
+        self.feature_names = list(feature_names)
+        self.mask_names = list(mask_names)
+
+        if n_samples < self.config.min_train_samples:
+            self.model = None
+            self.backend = "warmup"
+            self.last_fit_stats = {
+                "n_train": float(n_samples),
+                "train_mae": np.nan,
+                "val_mae": np.nan,
+                "instability_ratio": 1.0,
+            }
+            return self.last_fit_stats
+
+        x = np.asarray(features, dtype=float)[valid]
+        m = np.asarray(masks, dtype=float)[valid]
+        yv = y[valid]
+
+        x_trans = self._transform(x, m, fit=True)
+        self._train_x = x_trans
+        self._train_y = yv
+
+        self.model = self._build_model(n_samples=n_samples)
+        self.model.fit(x_trans, yv)
+
+        train_pred = self.model.predict(x_trans)
+        train_mae = float(np.mean(np.abs(train_pred - yv)))
+
+        # Simple rolling validation proxy.
+        if n_samples >= 12:
+            split = int(max(8, n_samples * 0.8))
+            x_tr, x_val = x_trans[:split], x_trans[split:]
+            y_tr, y_val = yv[:split], yv[split:]
+
+            val_model = self._build_model(n_samples=split)
+            val_model.fit(x_tr, y_tr)
+            val_pred = val_model.predict(x_val)
+            val_mae = float(np.mean(np.abs(val_pred - y_val))) if y_val.size else train_mae
+        else:
+            val_mae = train_mae
+
+        instability = float((val_mae + 1e-6) / (train_mae + 1e-6))
+        self.last_fit_stats = {
+            "n_train": float(n_samples),
+            "train_mae": train_mae,
+            "val_mae": val_mae,
+            "instability_ratio": instability,
+        }
+        return self.last_fit_stats
+
+    def _rf_uncertainty(self, x: np.ndarray) -> np.ndarray:
+        assert self.model is not None
+        if not hasattr(self.model, "estimators_"):
+            return np.full(x.shape[0], float(np.std(self._train_y)) if self._train_y is not None else 1.0)
+        preds = np.vstack([tree.predict(x) for tree in self.model.estimators_])
+        return np.std(preds, axis=0)
+
+    def predict_bundle(self, features: np.ndarray, masks: np.ndarray, topk_threshold: float | None = None) -> Dict[str, np.ndarray]:
+        n = features.shape[0]
+        if self.model is None:
+            return {
+                "expected_score": np.zeros(n, dtype=float),
+                "topk_probability": np.full(n, 0.5, dtype=float),
+                "uncertainty": np.full(n, 1.0, dtype=float),
+            }
+
+        x = self._transform(np.asarray(features, dtype=float), np.asarray(masks, dtype=float), fit=False)
+        expected = self.model.predict(x)
+
+        if self.backend == "random_forest":
+            uncertainty = self._rf_uncertainty(x)
+        else:
+            residual_scale = (
+                float(np.std(self._train_y - self.model.predict(self._train_x)))
+                if self._train_x is not None and self._train_y is not None
+                else 1.0
+            )
+            uncertainty = np.full(expected.shape[0], max(1e-3, residual_scale))
+
+        if topk_threshold is None:
+            topk_threshold = float(np.quantile(self._train_y, 0.8)) if self._train_y is not None else 0.0
+
+        z = (expected - topk_threshold) / (uncertainty + 1e-6)
+        topk_prob = 1.0 / (1.0 + np.exp(-z))
+        return {
+            "expected_score": expected.astype(float),
+            "topk_probability": topk_prob.astype(float),
+            "uncertainty": uncertainty.astype(float),
+        }
+
+    def feature_importance(self) -> Dict[str, float]:
+        if self.model is None or not hasattr(self.model, "feature_importances_"):
+            return {}
+
+        names = self.feature_names + self.mask_names
+        importances = np.asarray(self.model.feature_importances_, dtype=float)
+        if importances.size != len(names):
+            return {}
+        return {name: float(value) for name, value in zip(names, importances)}

libs/adaptive/thresholding.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Sequence
+
+import numpy as np
+
+
+@dataclass
+class DynamicThresholdConfig:
+    min_evaluated: int = 500
+    patience_rounds: int = 8
+    min_model_weight: float = 0.35
+    quantile: float = 0.15
+    uncertainty_weight: float = 0.20
+    min_improvement: float = 0.02
+    exploration_margin: float = 0.45
+    exploitation_margin: float = 0.10
+    reference_evaluations: int = 5000
+
+
+class DynamicEarlyStopController:
+    """
+    Conservative early-stop controller for adaptive replay.
+
+    Lower scores are considered better.
+    """
+
+    def __init__(self, config: DynamicThresholdConfig | None = None) -> None:
+        self.config = config or DynamicThresholdConfig()
+        self.best_score = np.inf
+        self.stagnant_rounds = 0
+        self.history: List[Dict[str, float | int | bool | str]] = []
+
+    def update(
+        self,
+        *,
+        round_idx: int,
+        n_evaluated: int,
+        all_scores: Sequence[float],
+        recent_scores: Sequence[float],
+        model_weight: float,
+        mean_uncertainty: float,
+    ) -> Dict[str, float | int | bool | str]:
+        cfg = self.config
+        scores = np.asarray(all_scores, dtype=float)
+        recent = np.asarray(recent_scores, dtype=float)
+
+        if scores.size == 0:
+            rec = {
+                "round_idx": int(round_idx),
+                "n_evaluated": int(n_evaluated),
+                "dynamic_threshold": np.nan,
+                "score_quantile": np.nan,
+                "best_score": np.nan,
+                "recent_mean_score": np.nan,
+                "mean_uncertainty": float(mean_uncertainty),
+                "model_weight": float(model_weight),
+                "stagnant_rounds": int(self.stagnant_rounds),
+                "eligible_for_stop": False,
+                "stop": False,
+                "reason": "no_scores",
+            }
+            self.history.append(rec)
+            return rec
+
+        score_quantile = float(np.nanquantile(scores, cfg.quantile))
+        best = float(np.nanmin(scores))
+        recent_mean = float(np.nanmean(recent)) if recent.size else float(np.nan)
+        uncertainty = float(max(0.0, mean_uncertainty))
+
+        if np.isfinite(self.best_score):
+            improvement = float(self.best_score - best)
+        else:
+            improvement = np.inf
+
+        if improvement > cfg.min_improvement:
+            self.stagnant_rounds = 0
+        else:
+            self.stagnant_rounds += 1
+        self.best_score = min(self.best_score, best)
+
+        coverage = float(min(1.0, n_evaluated / max(1.0, float(cfg.reference_evaluations))))
+        margin = (1.0 - coverage) * cfg.exploration_margin + coverage * cfg.exploitation_margin
+        dynamic_threshold = float(score_quantile + margin + cfg.uncertainty_weight * uncertainty)
+
+        eligible = (
+            int(n_evaluated) >= int(cfg.min_evaluated)
+            and float(model_weight) >= float(cfg.min_model_weight)
+        )
+        plateau = self.stagnant_rounds >= int(cfg.patience_rounds)
+        poor_recent = bool(np.isfinite(recent_mean) and recent_mean >= dynamic_threshold)
+        should_stop = bool(eligible and plateau and poor_recent)
+
+        if not eligible:
+            reason = "not_eligible"
+        elif not plateau:
+            reason = "improving_or_not_stagnant"
+        elif not poor_recent:
+            reason = "recent_batch_still_competitive"
+        else:
+            reason = "stagnation_above_dynamic_threshold"
+
+        rec = {
+            "round_idx": int(round_idx),
+            "n_evaluated": int(n_evaluated),
+            "dynamic_threshold": dynamic_threshold,
+            "score_quantile": score_quantile,
+            "best_score": self.best_score,
+            "recent_mean_score": recent_mean,
+            "mean_uncertainty": uncertainty,
+            "model_weight": float(model_weight),
+            "stagnant_rounds": int(self.stagnant_rounds),
+            "eligible_for_stop": bool(eligible),
+            "stop": should_stop,
+            "reason": reason,
+        }
+        self.history.append(rec)
+        return rec
+

libs/adaptive/weight_schedule.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Sequence
+
+
+@dataclass
+class WeightScheduleConfig:
+    sample_knots: tuple[int, int, int, int] = (20, 50, 100, 200)
+    weight_knots: tuple[float, float, float, float] = (0.1, 0.3, 0.5, 0.8)
+    max_weight: float = 0.9
+    min_weight: float = 0.05
+    instability_threshold: float = 2.0
+    instability_decay: float = 0.25
+
+
+def _interp(x: float, xs: Sequence[float], ys: Sequence[float]) -> float:
+    if x <= xs[0]:
+        return float(ys[0])
+    if x >= xs[-1]:
+        return float(ys[-1])
+
+    for i in range(1, len(xs)):
+        if x <= xs[i]:
+            x0, x1 = xs[i - 1], xs[i]
+            y0, y1 = ys[i - 1], ys[i]
+            t = (x - x0) / max(1e-9, (x1 - x0))
+            return float(y0 + t * (y1 - y0))
+    return float(ys[-1])
+
+
+def compute_model_weight(
+    n_samples: int,
+    instability_ratio: float = 1.0,
+    config: WeightScheduleConfig | None = None,
+) -> float:
+    cfg = config or WeightScheduleConfig()
+
+    base = _interp(float(n_samples), cfg.sample_knots, cfg.weight_knots)
+    if n_samples > cfg.sample_knots[-1]:
+        extra = min(cfg.max_weight - base, 0.05 * (n_samples - cfg.sample_knots[-1]) / 100.0)
+        base += max(0.0, extra)
+
+    if instability_ratio > cfg.instability_threshold:
+        base *= max(0.1, 1.0 - cfg.instability_decay)
+
+    base = max(cfg.min_weight, min(cfg.max_weight, base))
+    return float(base)

libs/analysis/backend_diagnostic.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+import numpy as np
+import pandas as pd
+
+
+REQUIRED_REFERENCE_DIAG_COLUMNS = [
+    "dataset",
+    "target_name",
+    "reference_ligand_id",
+    "reference_ligand_score",
+    "reference_ligand_rank_percentile",
+    "adaptive_best_score",
+    "exhaustive_best_score",
+]
+
+REQUIRED_BACKEND_COMPARISON_COLUMNS = [
+    "dataset",
+    "backend",
+    "analysis_scope",
+    "available",
+    "n_ligands",
+    "runtime_seconds",
+    "runtime_per_ligand",
+    "reference_ligand_score",
+    "reference_ligand_rank_percentile",
+    "best_score",
+    "score_gap_reference_vs_best",
+    "reference_pose_centroid_distance_A",
+    "reference_pose_in_expected_pocket",
+]
+
+REQUIRED_POCKET_PREP_COLUMNS = [
+    "dataset",
+    "backend",
+    "pocket_variant",
+    "prep_variant",
+    "reference_ligand_score",
+    "reference_pose_centroid_distance_A",
+    "reference_pose_in_expected_pocket",
+]
+
+
+@dataclass(frozen=True)
+class ManualAgentsCheck:
+    exists: bool
+    path: str
+    manually_read: bool
+
+
+def manual_agents_check(path: str | Path, manually_read: bool = True) -> ManualAgentsCheck:
+    p = Path(path).expanduser().resolve()
+    return ManualAgentsCheck(exists=p.exists(), path=str(p), manually_read=bool(manually_read and p.exists()))
+
+
+def _safe_float(x: Any, default: float = np.nan) -> float:
+    try:
+        v = float(x)
+        return float(v) if np.isfinite(v) else float(default)
+    except Exception:
+        return float(default)
+
+
+def compute_rank_percentile(df: pd.DataFrame, ligand_id: str, score_col: str, lower_is_better: bool = True) -> float:
+    if df.empty or score_col not in df.columns:
+        return np.nan
+    d = df[["ligand_id", score_col]].copy()
+    d["ligand_id"] = d["ligand_id"].astype(str)
+    d[score_col] = pd.to_numeric(d[score_col], errors="coerce")
+    d = d.dropna(subset=[score_col]).copy()
+    if d.empty:
+        return np.nan
+    d = d.sort_values(score_col, ascending=bool(lower_is_better)).reset_index(drop=True)
+    hit = d.index[d["ligand_id"] == str(ligand_id)]
+    if len(hit) == 0:
+        return np.nan
+    rank = int(hit[0]) + 1
+    return float(100.0 * rank / max(1, d.shape[0]))
+
+
+def select_suspicious_datasets(reference_diag_df: pd.DataFrame, threshold_pct: float = 25.0, max_deep: int = 2) -> list[str]:
+    if reference_diag_df.empty:
+        return []
+    d = reference_diag_df.copy()
+    d["reference_ligand_rank_percentile"] = pd.to_numeric(d["reference_ligand_rank_percentile"], errors="coerce")
+    d = d.dropna(subset=["reference_ligand_rank_percentile"]).copy()
+    d = d[d["reference_ligand_rank_percentile"] >= float(threshold_pct)].copy()
+    if d.empty:
+        return []
+    d = d.sort_values("reference_ligand_rank_percentile", ascending=False)
+    return d["dataset"].astype(str).head(int(max(1, max_deep))).tolist()
+
+
+def validate_required_columns(df: pd.DataFrame, required_columns: Iterable[str]) -> list[str]:
+    cols = set(df.columns)
+    missing = [c for c in required_columns if c not in cols]
+    return missing
+
+
+def recommend_toolchain(
+    backend_comparison_df: pd.DataFrame,
+    pocket_prep_df: pd.DataFrame,
+) -> dict[str, Any]:
+    """
+    Choose practical recommendation from diagnostic evidence.
+
+    Policy:
+    - Prefer backend with best median reference rank percentile under "subset_default" scope.
+    - Penalize poor runtime-per-ligand if >2x best runtime.
+    - Use pocket/prep gain to detect whether core issue is mostly preparation/pocket.
+    """
+    out: dict[str, Any] = {
+        "recommended_main_backend": "rdock",
+        "recommended_rescoring": "gnina_or_haddock_shortlist_optional",
+        "keep_haddock": "optional_shortlist_only",
+        "main_failure_source": "mixed",
+        "evidence": [],
+    }
+
+    bdf = backend_comparison_df.copy()
+    if not bdf.empty:
+        bdf = bdf[bdf["analysis_scope"].astype(str) == "subset_default"].copy()
+    if not bdf.empty:
+        bdf["runtime_per_ligand"] = pd.to_numeric(bdf["runtime_per_ligand"], errors="coerce")
+        bdf["reference_ligand_rank_percentile"] = pd.to_numeric(bdf["reference_ligand_rank_percentile"], errors="coerce")
+        agg = (
+            bdf.groupby("backend", as_index=False)
+            .agg(
+                median_ref_rank_pct=("reference_ligand_rank_percentile", "median"),
+                median_runtime=("runtime_per_ligand", "median"),
+                available_ratio=("available", "mean"),
+            )
+            .sort_values(["median_ref_rank_pct", "median_runtime"], ascending=[True, True])
+        )
+        if not agg.empty:
+            best = agg.iloc[0]
+            best_runtime = max(1e-9, _safe_float(best["median_runtime"], 1.0))
+            candidate = str(best["backend"])
+            if _safe_float(best["available_ratio"], 0.0) < 0.5:
+                out["evidence"].append("best_rank_backend_not_reliably_available")
+            else:
+                out["recommended_main_backend"] = candidate
+
+            rd = agg[agg["backend"].astype(str).str.lower() == "rdock"]
+            if not rd.empty:
+                rd_runtime = max(1e-9, _safe_float(rd.iloc[0]["median_runtime"], best_runtime))
+                if best_runtime > 2.0 * rd_runtime and candidate != "rdock":
+                    out["evidence"].append("candidate_backend_too_slow_vs_rdock")
+                    out["recommended_main_backend"] = "rdock"
+
+            out["evidence"].append(f"rank_runtime_table={agg.to_dict(orient='records')}")
+
+    pdf = pocket_prep_df.copy()
+    if not pdf.empty:
+        pdf["reference_ligand_score"] = pd.to_numeric(pdf["reference_ligand_score"], errors="coerce")
+        deltas: list[float] = []
+        for (_, _), sub in pdf.groupby(["dataset", "backend"]):
+            default = sub[(sub["pocket_variant"] == "default") & (sub["prep_variant"] == "default")]
+            if default.empty:
+                continue
+            default_score = _safe_float(default.iloc[0]["reference_ligand_score"], np.nan)
+            best_score = _safe_float(sub["reference_ligand_score"].min(), np.nan)
+            if np.isfinite(default_score) and np.isfinite(best_score):
+                deltas.append(default_score - best_score)
+        mean_gain = float(np.mean(np.asarray(deltas, dtype=float))) if deltas else 0.0
+        if mean_gain > 1.0:
+            out["main_failure_source"] = "pocket_or_preparation"
+        elif mean_gain > 0.2:
+            out["main_failure_source"] = "mixed"
+        else:
+            out["main_failure_source"] = "backend_scoring_limitations"
+        out["evidence"].append(f"mean_reference_gain_from_pocket_prep={mean_gain:.3f}")
+
+    out["keep_haddock"] = "optional_shortlist_only"
+    return out

libs/analysis/ranking.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+
+def resolve_reference_rank_percentile(
+    merged_df: pd.DataFrame,
+    reference_ligand_id: str,
+    *,
+    oracle_rank_col: str = "rank_percentile",
+    run_rank_col: str = "run_rank_percentile",
+) -> tuple[float, str]:
+    """
+    Resolve reference rank percentile with robust fallback.
+
+    Returns:
+    - rank percentile (float)
+    - source ("oracle", "run_fallback", "missing")
+    """
+    if merged_df.empty:
+        return float("nan"), "missing"
+
+    d = merged_df.copy()
+    if "ligand_id" not in d.columns:
+        return float("nan"), "missing"
+    d["ligand_id"] = d["ligand_id"].astype(str)
+    ref = d[d["ligand_id"] == str(reference_ligand_id)]
+    if ref.empty:
+        return float("nan"), "missing"
+
+    if oracle_rank_col in ref.columns:
+        oracle_val = pd.to_numeric(ref[oracle_rank_col], errors="coerce").iloc[0]
+        if np.isfinite(float(oracle_val)):
+            return float(oracle_val), "oracle"
+
+    if run_rank_col in d.columns:
+        run_val = pd.to_numeric(ref[run_rank_col], errors="coerce").iloc[0]
+        if np.isfinite(float(run_val)):
+            return float(run_val), "run_fallback"
+
+    return float("nan"), "missing"
+

libs/benchmark/__init__.py

@@ -0,0 +1,108 @@
+"""Benchmark utilities for large-scale and modality sanity-check runs."""
+
+from .cleanup import CleanupItem, execute_results_cleanup, plan_results_cleanup
+from .budget_efficiency import (
+    TimeImportanceControls,
+    clamp_time_importance,
+    controls_from_time_importance,
+    required_budget_metric_columns,
+    select_best_policy_budget,
+    summarize_diversity,
+    validate_budget_metric_schema,
+)
+from .disk_guard import (
+    DiskCleanupAction,
+    DiskSnapshot,
+    append_disk_snapshot,
+    requires_cleanup,
+    run_repository_local_cleanup,
+    snapshot_disk_state,
+    write_cleanup_actions,
+    write_disk_guard_report,
+)
+from .large_library import build_large_benchmark_library
+from .ordering import cluster_naive_order
+from .policy_repair import (
+    AdaptivePolicyVariant,
+    PolicyRuntimeState,
+    apply_stop_policy,
+    coverage_floor_reached,
+    coverage_fraction,
+    default_policy_variants,
+    effective_controls,
+    regret_stop_variant,
+    select_cluster_bootstrap_batch,
+)
+from .multifidelity import (
+    ExplorationControls,
+    StoppingControls,
+    UncertaintyControls,
+    controls_from_config,
+    enforce_control_limits,
+    simulate_multifidelity_policy,
+)
+from .overnight_stop import (
+    OBJECTIVES,
+    STOP_MODELS,
+    StopModelParams,
+    estimate_marginal_expected_gain,
+    estimate_probability_target_percentile,
+    is_trivial_objective_solution,
+    objective_value,
+    simulate_stop_model,
+)
+from .runtime import AUTO_MINUS_FOUR, ThreadAllocation, detect_system_threads, enforce_thread_fairness, resolve_threads_used
+from .reuse import ReuseCheck, validate_reuse_inputs
+
+__all__ = [
+    "AUTO_MINUS_FOUR",
+    "AdaptivePolicyVariant",
+    "CleanupItem",
+    "DiskCleanupAction",
+    "DiskSnapshot",
+    "PolicyRuntimeState",
+    "TimeImportanceControls",
+    "ThreadAllocation",
+    "ReuseCheck",
+    "apply_stop_policy",
+    "append_disk_snapshot",
+    "build_large_benchmark_library",
+    "clamp_time_importance",
+    "cluster_naive_order",
+    "coverage_floor_reached",
+    "coverage_fraction",
+    "controls_from_time_importance",
+    "default_policy_variants",
+    "detect_system_threads",
+    "effective_controls",
+    "estimate_marginal_expected_gain",
+    "estimate_probability_target_percentile",
+    "enforce_thread_fairness",
+    "execute_results_cleanup",
+    "is_trivial_objective_solution",
+    "objective_value",
+    "OBJECTIVES",
+    "STOP_MODELS",
+    "plan_results_cleanup",
+    "required_budget_metric_columns",
+    "regret_stop_variant",
+    "requires_cleanup",
+    "resolve_threads_used",
+    "run_repository_local_cleanup",
+    "simulate_multifidelity_policy",
+    "simulate_stop_model",
+    "StopModelParams",
+    "StoppingControls",
+    "ExplorationControls",
+    "UncertaintyControls",
+    "controls_from_config",
+    "enforce_control_limits",
+    "validate_reuse_inputs",
+    "select_best_policy_budget",
+    "select_cluster_bootstrap_batch",
+    "snapshot_disk_state",
+    "summarize_diversity",
+    "validate_budget_metric_schema",
+    "write_cleanup_actions",
+    "write_disk_guard_report",
+]

libs/benchmark/budget_efficiency.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable, List
+
+import numpy as np
+import pandas as pd
+
+from libs.adaptive.policies import PrioritizationPolicy
+
+
+def clamp_time_importance(value: float) -> float:
+    return float(max(0.0, min(1.0, float(value))))
+
+
+@dataclass(frozen=True)
+class TimeImportanceControls:
+    utility_weight: float
+    uncertainty_weight: float
+    diversity_weight: float
+    cluster_bonus_weight: float
+    threshold_stop_shift: float
+    exploration_additive: float
+
+
+def controls_from_time_importance(
+    base_policy: PrioritizationPolicy,
+    *,
+    exploration_boost: float,
+    time_importance: float,
+) -> TimeImportanceControls:
+    ti = clamp_time_importance(time_importance)
+    exp = float(max(0.0, exploration_boost))
+
+    adjusted_exp = float(max(0.0, exp + (1.0 - ti) * 0.22))
+    utility = max(0.15, float(base_policy.utility_weight) - 0.40 * adjusted_exp + 0.22 * ti)
+    uncertainty = max(0.05, float(base_policy.uncertainty_weight) + 0.22 * adjusted_exp - 0.10 * ti)
+    diversity = max(0.05, float(base_policy.diversity_weight) + 0.14 * adjusted_exp - 0.08 * ti)
+    cluster_bonus = float(base_policy.cluster_bonus_weight) + 0.04 * adjusted_exp
+    # Negative means easier stopping (more time-sensitive).
+    threshold_stop_shift = float(-0.20 * ti)
+    return TimeImportanceControls(
+        utility_weight=float(utility),
+        uncertainty_weight=float(uncertainty),
+        diversity_weight=float(diversity),
+        cluster_bonus_weight=float(cluster_bonus),
+        threshold_stop_shift=threshold_stop_shift,
+        exploration_additive=adjusted_exp,
+    )
+
+
+def required_budget_metric_columns() -> List[str]:
+    return [
+        "dataset",
+        "strategy",
+        "strategy_group",
+        "budget",
+        "time_importance",
+        "top10_recovery_fraction",
+        "top50_recovery_fraction",
+        "top100_recovery_fraction",
+        "best_docking_score",
+        "best_final_score",
+        "dockings_performed",
+        "wall_time_seconds",
+        "quality_per_time",
+        "quality_per_docking",
+        "auc_best_score_so_far",
+    ]
+
+
+def validate_budget_metric_schema(df: pd.DataFrame) -> List[str]:
+    missing = [c for c in required_budget_metric_columns() if c not in df.columns]
+    return missing
+
+
+def select_best_policy_budget(metrics_df: pd.DataFrame) -> pd.Series:
+    if metrics_df.empty:
+        raise ValueError("metrics_df is empty")
+    missing = validate_budget_metric_schema(metrics_df)
+    if missing:
+        raise ValueError(f"metrics_df missing required columns: {missing}")
+
+    d = metrics_df.copy()
+    if "strategy_group" in d.columns:
+        d = d[d["strategy_group"].astype(str) == "adaptive"].copy()
+    if d.empty:
+        raise ValueError("No adaptive rows found for selection")
+
+    for c in ["top10_recovery_fraction", "top50_recovery_fraction", "top100_recovery_fraction", "quality_per_time", "quality_per_docking"]:
+        d[f"rank_{c}"] = pd.to_numeric(d[c], errors="coerce").rank(method="average", ascending=False)
+    d["rank_budget"] = pd.to_numeric(d["budget"], errors="coerce").rank(method="average", ascending=True)
+    d["rank_best_final"] = pd.to_numeric(d["best_final_score"], errors="coerce").rank(method="average", ascending=True)
+
+    d["selection_score"] = (
+        0.24 * d["rank_top50_recovery_fraction"]
+        + 0.24 * d["rank_top100_recovery_fraction"]
+        + 0.20 * d["rank_top10_recovery_fraction"]
+        + 0.12 * d["rank_quality_per_docking"]
+        + 0.10 * d["rank_quality_per_time"]
+        + 0.06 * d["rank_best_final"]
+        + 0.04 * d["rank_budget"]
+    )
+    chosen = d.sort_values(["selection_score", "budget"], ascending=[True, True]).iloc[0]
+    return chosen
+
+
+def summarize_diversity(df: pd.DataFrame, *, similarity_col: str = "reference_similarity", scaffold_col: str = "scaffold_core") -> pd.DataFrame:
+    vals = pd.to_numeric(df.get(similarity_col, pd.Series(dtype=float)), errors="coerce").dropna()
+    bins = np.linspace(0.0, 1.0, 11)
+    hist, edges = np.histogram(vals.to_numpy(dtype=float), bins=bins)
+    out = pd.DataFrame(
+        {
+            "bin_left": edges[:-1],
+            "bin_right": edges[1:],
+            "count": hist,
+            "fraction": hist / max(1, int(hist.sum())),
+        }
+    )
+    out["unique_scaffold_count"] = int(df.get(scaffold_col, pd.Series(dtype=str)).astype(str).replace({"": np.nan}).dropna().nunique())
+    out["total_ligands"] = int(df.shape[0])
+    return out
+

libs/benchmark/cleanup.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Iterable, List
+
+
+@dataclass
+class CleanupItem:
+    path: Path
+    action: str
+    reason: str
+
+
+def plan_results_cleanup(
+    results_dir: Path,
+    *,
+    keep_dirs: Iterable[str] = (
+        "large_benchmark",
+        "discovery_benchmark",
+        "ppi_benchmark",
+        "ppi_sanity_check",
+        "experimental_benchmark_single_library",
+        "smoke_test",
+    ),
+) -> List[CleanupItem]:
+    keep = {str(x).strip() for x in keep_dirs}
+    items: List[CleanupItem] = []
+    if not results_dir.exists():
+        return items
+
+    for child in sorted(results_dir.iterdir()):
+        if not child.is_dir():
+            continue
+        if child.name in keep or child.name == "archive":
+            continue
+        items.append(
+            CleanupItem(
+                path=child,
+                action="archive",
+                reason="obsolete_or_legacy_result_artifact",
+            )
+        )
+    return items
+
+
+def execute_results_cleanup(results_dir: Path, plan: List[CleanupItem]) -> Path:
+    archive_root = results_dir / "archive" / datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+    archive_root.mkdir(parents=True, exist_ok=True)
+    for item in plan:
+        if item.action != "archive" or not item.path.exists():
+            continue
+        target = archive_root / item.path.name
+        if target.exists():
+            shutil.rmtree(target)
+        shutil.move(str(item.path), str(target))
+    return archive_root

libs/benchmark/disk_guard.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import gzip
+import os
+import shutil
+from dataclasses import dataclass, asdict
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Dict, Iterable, List
+
+import pandas as pd
+
+
+@dataclass
+class DiskSnapshot:
+    timestamp_utc: str
+    stage: str
+    note: str
+    free_gb: float
+    repo_size_gb: float
+    projected_output_gb: float
+    projected_free_after_gb: float
+
+
+@dataclass
+class DiskCleanupAction:
+    timestamp_utc: str
+    action: str
+    target: str
+    size_before_mb: float
+    size_after_mb: float
+    reclaimed_mb: float
+    status: str
+    reason: str
+
+
+def _utc_now() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def _is_within_repo(target: Path, repo_root: Path) -> bool:
+    try:
+        target.resolve().relative_to(repo_root.resolve())
+        return True
+    except Exception:
+        return False
+
+
+def directory_size_bytes(path: Path) -> int:
+    total = 0
+    if not path.exists():
+        return total
+    for entry in path.rglob("*"):
+        if entry.is_file():
+            try:
+                total += entry.stat().st_size
+            except OSError:
+                continue
+    return total
+
+
+def system_free_bytes(path: Path) -> int:
+    return int(shutil.disk_usage(path).free)
+
+
+def snapshot_disk_state(repo_root: Path, stage: str, note: str, projected_output_gb: float = 0.0) -> DiskSnapshot:
+    free = system_free_bytes(repo_root)
+    repo_size = directory_size_bytes(repo_root)
+    projected_after = max(0.0, (free / (1024**3)) - float(projected_output_gb))
+    return DiskSnapshot(
+        timestamp_utc=_utc_now(),
+        stage=stage,
+        note=note,
+        free_gb=free / (1024**3),
+        repo_size_gb=repo_size / (1024**3),
+        projected_output_gb=float(projected_output_gb),
+        projected_free_after_gb=projected_after,
+    )
+
+
+def append_disk_snapshot(csv_path: Path, snapshot: DiskSnapshot) -> None:
+    csv_path.parent.mkdir(parents=True, exist_ok=True)
+    row = pd.DataFrame([asdict(snapshot)])
+    if csv_path.exists():
+        old = pd.read_csv(csv_path)
+        out = pd.concat([old, row], ignore_index=True)
+    else:
+        out = row
+    out.to_csv(csv_path, index=False)
+
+
+def requires_cleanup(snapshot: DiskSnapshot, *, min_free_gb: float = 8.0) -> bool:
+    return bool(snapshot.projected_free_after_gb < float(min_free_gb))
+
+
+def _compress_file(path: Path) -> tuple[float, float]:
+    before = path.stat().st_size / (1024**2)
+    gz_path = path.with_suffix(path.suffix + ".gz")
+    with path.open("rb") as src, gzip.open(gz_path, "wb", compresslevel=6) as dst:
+        shutil.copyfileobj(src, dst)
+    path.unlink(missing_ok=True)
+    after = gz_path.stat().st_size / (1024**2)
+    return before, after
+
+
+def _prune_batches(raw_root: Path, keep_first_n: int) -> tuple[float, float]:
+    before = directory_size_bytes(raw_root) / (1024**2)
+    batches = sorted([p for p in raw_root.iterdir() if p.is_dir()])
+    for batch in batches[keep_first_n:]:
+        shutil.rmtree(batch, ignore_errors=True)
+    after = directory_size_bytes(raw_root) / (1024**2)
+    return before, after
+
+
+def run_repository_local_cleanup(
+    repo_root: Path,
+    *,
+    results_dir: Path,
+    keep_raw_batches: int = 6,
+) -> List[DiskCleanupAction]:
+    actions: List[DiskCleanupAction] = []
+
+    def record(action: str, target: Path, before: float, after: float, status: str, reason: str) -> None:
+        actions.append(
+            DiskCleanupAction(
+                timestamp_utc=_utc_now(),
+                action=action,
+                target=str(target),
+                size_before_mb=float(before),
+                size_after_mb=float(after),
+                reclaimed_mb=max(0.0, float(before - after)),
+                status=status,
+                reason=reason,
+            )
+        )
+
+    # 1) Remove replay caches after summary tables are present.
+    for replay in results_dir.glob("*/replay_cache"):
+        parent = replay.parent
+        if not _is_within_repo(replay, repo_root):
+            record("remove_dir", replay, 0.0, 0.0, "skipped", "outside_repo_guard")
+            continue
+        if not (parent / "summary.json").exists():
+            record("remove_dir", replay, 0.0, 0.0, "skipped", "missing_summary")
+            continue
+        before = directory_size_bytes(replay) / (1024**2)
+        shutil.rmtree(replay, ignore_errors=True)
+        after = directory_size_bytes(replay) / (1024**2) if replay.exists() else 0.0
+        record("remove_dir", replay, before, after, "ok", "replay_cache_not_required_for_final_reports")
+
+    # 2) Prune oversized raw output batches but keep representative subset.
+    for raw_root in list(results_dir.glob("*/raw_rdock_outputs")) + list(results_dir.glob("*/predock/raw_rdock_outputs")):
+        if not raw_root.exists() or not raw_root.is_dir():
+            continue
+        if not _is_within_repo(raw_root, repo_root):
+            record("prune_batches", raw_root, 0.0, 0.0, "skipped", "outside_repo_guard")
+            continue
+        before, after = _prune_batches(raw_root, keep_first_n=keep_raw_batches)
+        record("prune_batches", raw_root, before, after, "ok", "keep_representative_raw_batches_only")
+
+    # 3) Compress large logs.
+    for log_file in results_dir.rglob("*.log"):
+        if not log_file.exists() or not log_file.is_file():
+            continue
+        if not _is_within_repo(log_file, repo_root):
+            record("compress_log", log_file, 0.0, 0.0, "skipped", "outside_repo_guard")
+            continue
+        if log_file.stat().st_size < 2 * 1024 * 1024:
+            continue
+        before, after = _compress_file(log_file)
+        record("compress_log", log_file, before, after, "ok", "large_log_compression")
+
+    # 4) Remove stale duplicate work dirs if summaries exist.
+    for work_dir in results_dir.glob("*/work"):
+        parent = work_dir.parent
+        if not (parent / "summary.json").exists():
+            continue
+        if not _is_within_repo(work_dir, repo_root):
+            record("remove_work_dir", work_dir, 0.0, 0.0, "skipped", "outside_repo_guard")
+            continue
+        before = directory_size_bytes(work_dir) / (1024**2)
+        shutil.rmtree(work_dir, ignore_errors=True)
+        record("remove_work_dir", work_dir, before, 0.0, "ok", "parsed_outputs_already_persisted")
+
+    return actions
+
+
+def write_cleanup_actions(path: Path, actions: Iterable[DiskCleanupAction]) -> None:
+    lines = ["# Disk Cleanup Actions", ""]
+    actions = list(actions)
+    if not actions:
+        lines.append("- No cleanup actions executed.")
+    else:
+        for a in actions:
+            lines.append(
+                f"- [{a.timestamp_utc}] action={a.action} target=`{a.target}` status={a.status} "
+                f"reclaimed_mb={a.reclaimed_mb:.2f} reason={a.reason}"
+            )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def write_disk_guard_report(
+    path: Path,
+    snapshots: Iterable[DiskSnapshot],
+    actions: Iterable[DiskCleanupAction],
+    *,
+    min_free_gb: float,
+) -> None:
+    snaps = list(snapshots)
+    acts = list(actions)
+    lines = [
+        "# Disk Guard Report",
+        "",
+        f"- Min free threshold (GB): `{min_free_gb}`",
+        f"- Snapshots captured: `{len(snaps)}`",
+        f"- Cleanup actions: `{len(acts)}`",
+        "",
+        "## Snapshot Timeline",
+    ]
+    for s in snaps:
+        lines.append(
+            f"- [{s.timestamp_utc}] stage={s.stage} free_gb={s.free_gb:.2f} repo_size_gb={s.repo_size_gb:.2f} "
+            f"projected_output_gb={s.projected_output_gb:.2f} projected_free_after_gb={s.projected_free_after_gb:.2f} note={s.note}"
+        )
+    lines.extend(["", "## Cleanup Summary"])
+    reclaimed = sum(a.reclaimed_mb for a in acts if a.status == "ok")
+    lines.append(f"- Total reclaimed MB: `{reclaimed:.2f}`")
+    outside_repo_violations = [a for a in acts if a.reason == "outside_repo_guard" and a.status == "ok"]
+    lines.append(f"- Outside-repo destructive actions: `{len(outside_repo_violations)}`")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(lines), encoding="utf-8")
+