Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

rdkit: test the helper and the verdict to full coverage; keep energies with their conformers

deeee1e0dff8555
diff --git a/store/agents/rdkit/toolchain/harness_rdkit.py b/store/agents/rdkit/toolchain/harness_rdkit.py
index 4d8f34c79..023c224f8 100644
--- a/store/agents/rdkit/toolchain/harness_rdkit.py
+++ b/store/agents/rdkit/toolchain/harness_rdkit.py
@@ -951,10 +951,12 @@ def load_structure(path: "str | Path") -> Chem.Mol:
base = Chem.Mol(records[0])
elements = [a.GetAtomicNum() for a in base.GetAtoms()]
energies: list[float] = []
+ kept = records[:1] # the records whose conformer base carries, so each energy stays with its conformer
for extra in records[1:]:
if [a.GetAtomicNum() for a in extra.GetAtoms()] == elements and extra.GetNumConformers():
base.AddConformer(Chem.Conformer(extra.GetConformer()), assignId=True)
- for k, record in enumerate(records[: base.GetNumConformers()]):
+ kept.append(extra)
+ for record in kept:
if record.HasProp("energy"):
try:
energies.append(float(record.GetProp("energy")))
diff --git a/store/agents/rdkit/toolchain/test_harness_rdkit.py b/store/agents/rdkit/toolchain/test_harness_rdkit.py
new file mode 100644
index 000000000..844e0d03e
--- /dev/null
+++ b/store/agents/rdkit/toolchain/test_harness_rdkit.py
@@ -0,0 +1,752 @@
+"""The helper on the pinned RDKit: `"$RDKIT_PYTHON" -m unittest toolchain/test_harness_rdkit.py`.
+
+Small molecules and few conformers, so the whole file runs in seconds. The paths RDKit rarely takes — an
+embedding that fails, a build without Cairo, a labeller that refuses a valence — are stubbed at the one
+RDKit call that decides them. Skipped where RDKit is not installed (plain `python3`).
+"""
+import contextlib
+import hashlib
+import io
+import json
+import os
+import runpy
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).parent))
+try:
+ from rdkit import Chem
+ from rdkit.Chem import AllChem, rdDetermineBonds
+ import harness_rdkit as h
+except ImportError: # plain python3: the verdict's tests still run, these skip
+ h = None
+
+needs_rdkit = unittest.skipIf(h is None, "RDKit is not installed for this Python")
+
+IBUPROFEN = "CC(C)Cc1ccc(cc1)C(C)C(=O)O"
+IBUPROFEN_OH = "CC(C)(O)Cc1ccc(C(C)C(=O)O)cc1"
+METHANE_MOL2 = """@<TRIPOS>MOLECULE
+methane
+ 5 4 0 0 0
+SMALL
+NO_CHARGES
+
+@<TRIPOS>ATOM
+ 1 C1 0.0000 0.0000 0.0000 C.3 1 UNL1 0.0000
+ 2 H1 0.6291 0.6291 0.6291 H 1 UNL1 0.0000
+ 3 H2 -0.6291 -0.6291 0.6291 H 1 UNL1 0.0000
+ 4 H3 -0.6291 0.6291 -0.6291 H 1 UNL1 0.0000
+ 5 H4 0.6291 -0.6291 -0.6291 H 1 UNL1 0.0000
+@<TRIPOS>BOND
+ 1 1 2 1
+ 2 1 3 1
+ 3 1 4 1
+ 4 1 5 1
+"""
+
+
+def quiet(fn, *args, **kwargs):
+ """Call `fn`, returning (its result, what it printed)."""
+ out = io.StringIO()
+ with contextlib.redirect_stdout(out):
+ result = fn(*args, **kwargs)
+ return result, out.getvalue()
+
+
+def failing_then_real(real, fails=1, value=-1):
+ """A stand-in for an RDKit call that fails `fails` times, then is the real call. Records whether each
+ call asked for random coordinates."""
+ calls = []
+
+ def call(mol, *args, **kwargs):
+ params = kwargs.get("params", args[-1] if args else None)
+ calls.append(bool(getattr(params, "useRandomCoords", False)))
+ return value if len(calls) <= fails else real(mol, *args, **kwargs)
+ return call, calls
+
+
+class Case(unittest.TestCase):
+ def setUp(self):
+ tmp = tempfile.TemporaryDirectory()
+ self.addCleanup(tmp.cleanup)
+ self.out = Path(tmp.name).resolve()
+
+ def lead(self, smiles=IBUPROFEN, name="ibuprofen", conformers=1, parent=False):
+ mol = h.mol_from_smiles(smiles, name)
+ mol = h.embed_conformers(mol, n=conformers)
+ return quiet(h.write_outputs, mol, name, self.out, parent=parent)[0]
+
+
+@needs_rdkit
+class Helpers(Case):
+ def test_write_goes_through_a_hidden_temporary_and_takes_text_or_bytes(self):
+ h._write(self.out / "a.txt", "text")
+ h._write(self.out / "b.bin", b"\x00\x01")
+ self.assertEqual((self.out / "a.txt").read_text(), "text")
+ self.assertEqual((self.out / "b.bin").read_bytes(), b"\x00\x01")
+ self.assertEqual(sorted(p.name for p in self.out.iterdir()), ["a.txt", "b.bin"])
+
+ def test_a_smarts_pattern_is_compiled_once(self):
+ self.assertIs(h._pattern("[OX2H]"), h._pattern("[OX2H]"))
+
+ def test_progress_tells_the_pane_the_stage(self):
+ h.progress(self.out / "sub", "caffeine", "embedding", "10 conformers")
+ data = json.loads((self.out / "sub" / h.PROGRESS).read_text())
+ self.assertEqual((data["name"], data["stage"], data["detail"], data["pid"]), ("caffeine", "embedding", "10 conformers", os.getpid()))
+
+ def test_progress_never_raises(self):
+ blocker = self.out / "file"
+ blocker.write_text("")
+ h.progress(blocker, "x", "embedding") # out is a file: mkdir fails, the design goes on
+ self.assertEqual(blocker.read_text(), "")
+
+ def test_mol_from_smiles_names_the_molecule_and_refuses_typos(self):
+ self.assertEqual(h.mol_from_smiles("CCO").GetProp("_Name"), "CCO")
+ self.assertEqual(h.mol_from_smiles("CCO", "ethanol").GetProp("_Name"), "ethanol")
+ with self.assertRaisesRegex(ValueError, r"not a valid SMILES: 'C1CC'"):
+ h.mol_from_smiles("C1CC")
+
+ def test_similarity_and_substructure(self):
+ self.assertEqual(h.similarity("c1ccccc1O", "c1ccccc1O"), 1.0)
+ self.assertLess(h.similarity("c1ccccc1O", h.mol_from_smiles("CCCCCC")), 0.3)
+ self.assertEqual(len(h.substructure("OCCO", "[OX2H]")), 2)
+ self.assertEqual(h.substructure("CCC", "[OX2H]"), ())
+ with self.assertRaisesRegex(ValueError, "not a valid SMARTS"):
+ h.substructure("CCO", "[OX2H")
+
+ def test_read_smi_and_table(self):
+ smi = self.out / "list.smi"
+ smi.write_text("# a series\n\nCCO ethanol\nOCCO ethylene glycol \nC\n")
+ mols = h.read_smi(smi)
+ self.assertEqual([m.GetProp("_Name") for m in mols], ["ethanol", "ethylene glycol", "C"])
+ rows = h.table([mols[0], Chem.MolFromSmiles("O")])
+ self.assertEqual([(r["name"], r["formula"]) for r in rows], [("ethanol", "C2H6O"), ("", "H2O")])
+
+
+@needs_rdkit
+class Embedding(Case):
+ def test_embed_3d_minimises_one_conformer(self):
+ mol = h.embed_3d(h.mol_from_smiles("CCO", "ethanol"))
+ self.assertEqual((mol.GetNumAtoms(), mol.GetNumConformers(), mol.GetProp("_Name")), (9, 1, "ethanol"))
+ self.assertEqual(mol.GetProp("forcefield"), "MMFF94")
+ self.assertLessEqual(mol.GetDoubleProp("energy"), mol.GetDoubleProp("energy_before"))
+ self.assertEqual(json.loads(mol.GetProp("conformer_energies")), [round(mol.GetDoubleProp("energy"), 4)])
+
+ def test_an_unnamed_molecule_is_named_by_its_smiles(self):
+ self.assertEqual(h.embed_3d(Chem.MolFromSmiles("OCC")).GetProp("_Name"), "CCO")
+ self.assertEqual(h.embed_conformers(Chem.MolFromSmiles("OCC"), n=3).GetProp("_Name"), "CCO")
+
+ def test_embed_3d_retries_with_random_coordinates(self):
+ call, calls = failing_then_real(h.rdDistGeom.EmbedMolecule)
+ with mock.patch.object(h.rdDistGeom, "EmbedMolecule", call):
+ mol = h.embed_3d(h.mol_from_smiles("CCO"))
+ self.assertEqual(calls, [False, True])
+ self.assertEqual(mol.GetNumConformers(), 1)
+
+ def test_embed_3d_says_so_when_nothing_embeds(self):
+ with mock.patch.object(h.rdDistGeom, "EmbedMolecule", return_value=-1), \
+ self.assertRaisesRegex(RuntimeError, "no 3D embedding for CCO"):
+ h.embed_3d(h.mol_from_smiles("CCO"))
+
+ def test_uff_stands_in_when_mmff_has_no_parameters(self):
+ self.assertEqual(h.embed_3d(h.mol_from_smiles("CB(C)C")).GetProp("forcefield"), "UFF")
+ self.assertEqual(h.embed_conformers(h.mol_from_smiles("CB(C)C"), n=3).GetProp("forcefield"), "UFF")
+
+ def test_one_conformer_asked_is_embed_3d(self):
+ mol = h.embed_conformers(h.mol_from_smiles("CCCC"), n=1)
+ self.assertEqual(mol.GetNumConformers(), 1)
+
+ def test_the_search_keeps_distinct_minima_lowest_first_and_reports_its_stages(self):
+ stages = []
+ mol = h.embed_conformers(h.mol_from_smiles("CCCC", "butane"), n=10, on_stage=lambda s, d: stages.append(s))
+ energies = json.loads(mol.GetProp("conformer_energies"))
+ self.assertEqual(mol.GetNumConformers(), 3)
+ self.assertEqual(energies, sorted(energies))
+ self.assertAlmostEqual(mol.GetDoubleProp("energy"), energies[0], places=3)
+ self.assertEqual(stages, ["embedding", "minimising"])
+ self.assertFalse(mol.HasProp("unspecified_stereo"))
+
+ def test_n_caps_the_ensemble_and_the_window_drops_strained_minima(self):
+ self.assertEqual(h.embed_conformers(h.mol_from_smiles("CCCC"), n=2).GetNumConformers(), 2)
+ self.assertEqual(h.embed_conformers(h.mol_from_smiles("CCCC"), n=10, window=0.5).GetNumConformers(), 1)
+
+ def test_a_duplicate_minimum_is_dropped(self):
+ seen = []
+ real = h._best_rms
+
+ def spy(*args):
+ seen.append(real(*args))
+ return seen[-1]
+ with mock.patch.object(h, "_best_rms", spy):
+ mol = h.embed_conformers(h.mol_from_smiles("C1CCCCC1"), n=10)
+ self.assertTrue(any(rms < 0.3 for rms in seen), seen)
+ self.assertEqual(mol.GetNumConformers(), 2)
+
+ def test_a_single_minimum_is_not_aligned(self):
+ with mock.patch.object(h.rdMolAlign, "AlignMolConformers") as align:
+ mol = h.embed_conformers(h.mol_from_smiles("C"), n=5)
+ self.assertEqual(mol.GetNumConformers(), 1)
+ align.assert_not_called()
+
+ def test_the_search_retries_with_random_coordinates_then_gives_up(self):
+ call, calls = failing_then_real(h.rdDistGeom.EmbedMultipleConfs, value=[])
+ with mock.patch.object(h.rdDistGeom, "EmbedMultipleConfs", call):
+ self.assertGreater(h.embed_conformers(h.mol_from_smiles("CCCC"), n=3).GetNumConformers(), 0)
+ self.assertEqual(calls, [False, True])
+ with mock.patch.object(h.rdDistGeom, "EmbedMultipleConfs", return_value=[]), \
+ self.assertRaisesRegex(RuntimeError, "no 3D embedding for CCCC"):
+ h.embed_conformers(h.mol_from_smiles("CCCC"), n=3)
+
+ def test_an_unspecified_stereocentre_is_pinned_across_the_ensemble_and_recorded(self):
+ mol = h.embed_conformers(h.mol_from_smiles("CC(N)O"), n=5)
+ self.assertEqual(json.loads(mol.GetProp("unspecified_stereo")), [1])
+ labels = set()
+ for conf in mol.GetConformers():
+ probe = Chem.Mol(mol)
+ Chem.AssignStereochemistryFrom3D(probe, confId=conf.GetId())
+ labels.add(probe.GetAtomWithIdx(1).GetProp("_CIPCode"))
+ self.assertEqual(len(labels), 1)
+
+ def test_pin_stereo_leaves_the_centre_alone_when_the_probe_does_not_embed(self):
+ molh = Chem.AddHs(h.mol_from_smiles("CC(N)O"))
+ with mock.patch.object(h.rdDistGeom, "EmbedMolecule", return_value=-1):
+ self.assertEqual(h._pin_stereo(molh, 7), [1])
+ self.assertEqual(molh.GetAtomWithIdx(1).GetChiralTag(), Chem.ChiralType.CHI_UNSPECIFIED)
+ self.assertEqual(h._pin_stereo(Chem.AddHs(h.mol_from_smiles("CCO")), 7), [])
+
+ def test_best_rms_falls_back_to_the_plain_rms(self):
+ skeleton = Chem.RemoveHs(h.embed_conformers(h.mol_from_smiles("CCCC"), n=3))
+ with mock.patch.object(h.rdMolAlign, "GetBestRMS", side_effect=RuntimeError("too many matches")):
+ rms = h._best_rms(skeleton, 0, 1)
+ self.assertAlmostEqual(rms, AllChem.GetConformerRMS(Chem.Mol(skeleton), 1, 0))
+
+ def test_stereocentres_fall_back_to_the_legacy_labeller(self):
+ real = Chem.FindMolChiralCenters
+ calls = []
+
+ def labeller(mol, **kwargs):
+ calls.append(kwargs["useLegacyImplementation"])
+ if not kwargs["useLegacyImplementation"]:
+ raise RuntimeError("Invariant Violation")
+ return real(mol, **kwargs)
+ with mock.patch.object(h.Chem, "FindMolChiralCenters", labeller):
+ self.assertEqual(h._stereocentres(h.mol_from_smiles("CC(N)O")), [(1, "?")])
+ self.assertEqual(calls, [False, True])
+
+
+@needs_rdkit
+class Describing(Case):
+ def test_the_properties_of_ibuprofen_pass_the_rules(self):
+ props = h.properties(h.mol_from_smiles(IBUPROFEN))
+ self.assertEqual((props["formula"], props["mw"], props["hbd"], props["hba"]), ("C13H18O2", 206.28, 1, 1))
+ self.assertEqual((props["lipinski_violations"], props["veber_violations"]), (0, 0))
+ self.assertEqual((props["stereocenters"], props["unspecified_stereocenters"]), (1, 1))
+
+ def test_each_violated_rule_is_listed(self):
+ props = h.properties(h.mol_from_smiles("C" * 30 + "C(=O)O"))
+ self.assertEqual([v.split()[0] for v in props["lipinski"]], ["logp"])
+ self.assertEqual([v.split()[0] for v in props["veber"]], ["rotatable_bonds"])
+ self.assertEqual((props["lipinski_violations"], props["veber_violations"]), (1, 1))
+
+ def test_functional_groups_claim_their_heteroatoms_once(self):
+ names = lambda smiles: [g["name"] for g in h.functional_groups(h.mol_from_smiles(smiles))] # noqa: E731
+ self.assertEqual(names("CC(=O)OC"), ["Ester"]) # the ester's O is not also an ether
+ self.assertEqual(names("OC(=O)c1ccccc1"), ["Carboxylic acid", "Benzene ring"])
+ self.assertEqual(names("c1ccc2ccccc2c1"), ["Naphthalene"]) # its benzene rings are part of it
+ self.assertEqual(names("c1nncs1"), ["Aromatic ring"]) # aromatic, but not a named ring
+ self.assertEqual(names("C1CCCCC1"), [])
+ self.assertEqual(h.functional_groups(h.mol_from_smiles("OC(=O)CC"))[0]["atoms"], [0, 1, 2])
+
+ def test_structural_alerts_name_their_catalog(self):
+ alerts = h.structural_alerts(h.mol_from_smiles("Oc1ccccc1O"))
+ self.assertEqual([(a["catalog"], a["name"]) for a in alerts], [("PAINS", "Catechol A"), ("Brenk", "Catechol")])
+ self.assertEqual(h.structural_alerts(h.mol_from_smiles("CCO")), [])
+
+ def test_depict_draws_a_png_with_cairo_or_without_it(self):
+ mol = h.embed_3d(h.mol_from_smiles("CCO"))
+ self.assertTrue(h.depict(mol, self.out / "cairo.png").read_bytes().startswith(b"\x89PNG"))
+ no_cairo = SimpleNamespace(MolDraw2DCairo=mock.Mock(side_effect=RuntimeError("built without Cairo")))
+ with mock.patch.object(h, "rdMolDraw2D", no_cairo):
+ path = h.depict(mol, str(self.out / "pillow.png"))
+ self.assertTrue(path.read_bytes().startswith(b"\x89PNG"))
+
+ def test_an_svg_for_a_single_atom_has_no_bond_to_scale_by(self):
+ flat = Chem.MolFromSmiles("C")
+ h.rdDepictor.Compute2DCoords(flat)
+ svg, coords, (width, height) = h._draw_svg(flat)
+ self.assertIn("<svg", svg)
+ self.assertEqual(len(coords), 1)
+ self.assertGreater(width * height, 0)
+
+ def test_the_flat_molecule_maps_back_to_the_3d_indices(self):
+ mol = Chem.AddHs(h.mol_from_smiles("OCC"))
+ flat, to3d = h._flat_with_map(mol)
+ self.assertEqual((flat.GetNumAtoms(), to3d), (3, [0, 1, 2]))
+ self.assertEqual(mol.GetNumAtoms(), 9) # the 3D model keeps its hydrogens
+
+ def test_the_formula_delta_names_what_changed(self):
+ self.assertEqual(h._formula_delta("C2H6O", "C2H6O"), "isomer")
+ self.assertEqual(h._formula_delta("C2H6", "C2H4"), "+2H")
+ self.assertEqual(h._formula_delta("C3H8O", "C2H6"), "+C +O")
+ self.assertEqual(h._formula_delta("C2H3O2-", "C4H8O2"), "−2C")
+ self.assertEqual(h._formula_delta("C6H5Cl", "C6H6"), "+Cl")
+ self.assertEqual(h._formula_delta("C6H5N+", "C6H5O"), "+N −O")
+
+
+def flag_props(**overrides):
+ base = {"lipinski_violations": 0, "lipinski": [], "veber_violations": 0, "veber": [], "logp": 2.0, "tpsa": 50.0,
+ "qed": 0.5, "formal_charge": 0, "fsp3": 0.5, "aromatic_rings": 0}
+ return {**base, **overrides}
+
+
+@needs_rdkit
+class Flags(unittest.TestCase):
+ def flags(self, groups=(), alerts=(), centres=(), geometry=None, **props):
+ return [(f["level"], f["text"]) for f in h._flags(flag_props(**props), list(groups), list(alerts), list(centres), geometry or {})]
+
+ def test_a_quiet_molecule_gets_only_good_news(self):
+ self.assertEqual([level for level, _ in self.flags()], ["good", "good", "good", "good"])
+
+ def test_the_rule_of_five_one_violation_is_a_note_two_a_warning(self):
+ self.assertIn(("note", "One Lipinski violation (mw 612 > 500) — still inside the rule, which allows one."),
+ self.flags(lipinski_violations=1, lipinski=["mw 612 > 500"]))
+ self.assertEqual(self.flags(lipinski_violations=2)[0][0], "warn")
+
+ def test_veber_logp_tpsa_and_qed_each_have_their_bands(self):
+ self.assertEqual(self.flags(veber_violations=1, veber=["tpsa 150 > 140"])[1][0], "warn")
+ self.assertIn("very lipophilic", self.flags(logp=6.0)[2][1])
+ self.assertEqual(self.flags(logp=4.0)[2][0], "note")
+ self.assertIn("is polar", self.flags(logp=-1.0)[2][1])
+ self.assertEqual(self.flags(tpsa=120.0)[3][0], "note")
+ self.assertEqual(self.flags(tpsa=150.0)[3][0], "warn")
+ self.assertIn(("good", "QED 0.8 — attractive by the 2012 drug-likeness score (≥ 0.67)."), self.flags(qed=0.8))
+ self.assertIn(("warn", "QED 0.2 — unattractive by the drug-likeness score (< 0.35)."), self.flags(qed=0.2))
+
+ def test_groups_stereo_charge_flatness_and_alerts_add_notes(self):
+ flags = self.flags(groups=[{"name": "Tetrazole"}, {"name": "Tertiary amine"}], alerts=[{"catalog": "PAINS", "name": "Catechol A"}],
+ centres=[(1, "?"), (4, "?"), (7, "R")], geometry={1: "S"}, formal_charge=-1, fsp3=0.1, aromatic_rings=2)
+ texts = [text for _, text in flags[4:]]
+ self.assertTrue(texts[0].startswith("Acidic group"))
+ self.assertTrue(texts[1].startswith("Basic amine"))
+ self.assertIn("2 stereocentres unspecified in the SMILES — the 3D model shows one arbitrary configuration (S, ?).", texts[2])
+ self.assertEqual(texts[3], "Net formal charge -1.")
+ self.assertTrue(texts[4].startswith("Flat and aromatic-rich (Fsp3 0.1, 2 aromatic rings)"))
+ self.assertEqual(texts[5], "PAINS alert: Catechol A — a substructure worth a second look.")
+ self.assertIn("1 stereocentre unspecified", self.flags(centres=[(1, "?")])[4][1])
+
+
+@needs_rdkit
+class Series(Case):
+ def sdf(self, name, smiles, age):
+ path = self.out / name
+ path.write_text(Chem.MolToMolBlock(h.embed_3d(h.mol_from_smiles(smiles))) + "$$$$\n")
+ stamp = time.time() - age
+ os.utime(path, (stamp, stamp))
+ return path
+
+ def test_series_json_is_read_as_written(self):
+ (self.out / h.SERIES).write_text(json.dumps({"molecules": [{"name": "a"}]}))
+ self.assertEqual(h.read_series(self.out), {"molecules": [{"name": "a"}]})
+
+ def test_a_folder_from_before_series_json_is_listed_from_its_sdfs_oldest_first(self):
+ (self.out / h.SERIES).write_text(json.dumps(["not", "a", "series"]))
+ self.sdf("new.sdf", "CCO", age=10)
+ self.sdf("old.sdf", "C", age=100)
+ self.sdf("new.conformers.sdf", "CCO", age=0)
+ self.sdf(".hidden.sdf", "CCO", age=0)
+ (self.out / "torn.sdf").write_text("not a molecule\n")
+ series = h.read_series(self.out)
+ self.assertEqual([(m["name"], m["smiles"], m["legacy"], m["parent"]) for m in series["molecules"]],
+ [("old", "C", True, None), ("new", "CCO", True, None)])
+
+ def test_a_torn_or_missing_series_is_no_series(self):
+ (self.out / h.SERIES).write_text('{"molecules": [')
+ self.assertEqual(h.read_series(self.out)["molecules"], [])
+ self.assertEqual(h.read_series(self.out / "nowhere"), {"spec": "rdkit-series/1", "molecules": []})
+
+ def test_read_first_is_none_for_a_missing_or_unreadable_file(self):
+ (self.out / "torn.sdf").write_text("not a molecule\n")
+ self.assertIsNone(h._read_first(self.out / "torn.sdf"))
+ self.assertIsNone(h._read_first(self.out / "missing.sdf"))
+
+
+@needs_rdkit
+class Parents(Case):
+ def test_the_parent_is_the_closest_earlier_analogue_never_a_later_one(self):
+ series = {"molecules": [{"name": "far", "smiles": "c1ccccc1"}, {"name": "lead", "smiles": "CCCCCCO"},
+ {"name": "me", "smiles": "CCCCCCN"}, {"name": "later", "smiles": "CCCCCCN"}]}
+ entry, score = h._infer_parent("me", h.mol_from_smiles("CCCCCCN"), series)
+ self.assertEqual(entry["name"], "lead")
+ self.assertAlmostEqual(score, h.similarity("CCCCCCO", "CCCCCCN"))
+
+ def test_children_unreadable_and_unrelated_molecules_are_never_the_parent(self):
+ series = {"molecules": [{"name": "child", "smiles": "CCCCCCN", "parent": "me"}, {"name": "unnamed"},
+ {"name": "typo", "smiles": "C1CC"}, {"name": "salt", "smiles": "[Na+].[Cl-]"}]}
+ self.assertEqual(h._infer_parent("me", h.mol_from_smiles("CCCCCCN"), series), (None, 0.0))
+
+ def test_sharing_a_fragment_is_not_being_an_analogue(self):
+ series = {"molecules": [{"name": "lead", "smiles": "CCCCCCO"}]}
+ with mock.patch.object(h, "_mcs", return_value=SimpleNamespace(numAtoms=1)):
+ self.assertEqual(h._infer_parent("me", h.mol_from_smiles("CCCCCCN"), series), (None, 0.0))
+
+ def test_the_largest_overlap_wins_over_a_later_candidate(self):
+ series = {"molecules": [{"name": "same", "smiles": "CCCCCCN"}, {"name": "close", "smiles": "CCCCCCO"}]}
+ entry, score = h._infer_parent("me", h.mol_from_smiles("CCCCCCN"), series)
+ self.assertEqual((entry["name"], score), ("same", 1.0))
+
+ def test_the_parent_template_comes_from_its_sdf_or_else_its_smiles(self):
+ self.lead("CCO", "ethanol")
+ flat, to3d, record = h._parent_template({"name": "ethanol", "smiles": "CCO"}, self.out)
+ self.assertEqual((flat.GetNumAtoms(), to3d, record["name"]), (3, [0, 1, 2], "ethanol"))
+ (self.out / "ethanol.molecule.json").write_text("{")
+ (self.out / "torn.sdf").write_text("not a molecule\n")
+ flat, to3d, record = h._parent_template({"name": "ethanol", "smiles": "OCC", "sdf": "torn.sdf"}, self.out)
+ self.assertEqual((flat.GetNumAtoms(), to3d, record), (3, [0, 1, 2], None))
+ flat, _, record = h._parent_template({"name": "gone", "smiles": "CCCO"}, self.out)
+ self.assertEqual((flat.GetNumAtoms(), record), (4, None))
+
+ def relation(self, parent, smiles=IBUPROFEN_OH, name="ibuprofen_oh"):
+ mol = h.embed_3d(h.mol_from_smiles(smiles, name))
+ flat, to3d = h._flat_with_map(mol)
+ return h._relation(flat, to3d, name, parent, self.out, h.read_series(self.out))
+
+ def test_no_parent_asked_or_found(self):
+ self.assertEqual(self.relation(False), (None, None, None))
+ self.assertEqual(self.relation(None), (None, None, None))
+ self.assertEqual(self.relation(42), (None, None, None))
+
+ def test_a_parent_named_in_the_series_is_resolved_with_its_template(self):
+ self.lead()
+ record, template, query = self.relation("ibuprofen")
+ self.assertEqual((record["name"], record["inferred"], record["change"], record["sdf"]), ("ibuprofen", False, "+O", "ibuprofen.sdf"))
+ self.assertEqual((record["shared_atoms"], record["removed_atoms"]), (15, 0))
+ self.assertAlmostEqual(record["deltas"]["mw"], 16.0, places=0)
+ self.assertEqual(len(record["changed"]), 1)
+ self.assertIsNotNone(query)
+ parent = json.loads((self.out / "ibuprofen.molecule.json").read_text())
+ drawn = {row[0]: (row[3], row[4]) for row in parent["depiction"]["atoms"]}
+ position = template.GetConformer().GetAtomPosition(0)
+ self.assertEqual((round(position.x, 4), round(position.y, 4)), drawn[0]) # the parent's own 2D layout
+
+ def test_a_parent_depiction_without_every_atom_is_laid_out_afresh(self):
+ self.lead()
+ path = self.out / "ibuprofen.molecule.json"
+ record = json.loads(path.read_text())
+ record["depiction"]["atoms"] = [row[:3] for row in record["depiction"]["atoms"]]
+ path.write_text(json.dumps(record))
+ _, template, _ = self.relation("ibuprofen")
+ self.assertEqual(template.GetNumConformers(), 1)
+
+ def test_a_parent_given_as_smiles_is_matched_to_the_series_or_named_by_it(self):
+ self.lead()
+ record, _, _ = self.relation("OC(=O)C(C)c1ccc(CC(C)C)cc1") # ibuprofen, written another way
+ self.assertEqual(record["name"], "ibuprofen")
+ record, _, _ = self.relation("CCc1ccccc1")
+ self.assertEqual((record["name"], record["sdf"]), ("CCc1ccccc1", None))
+ record, _, _ = self.relation("CCCCCCCCCCc1ccc(cc1)C(CCCCCCCCCCCC)C(=O)O")
+ self.assertEqual(record["name"], "parent")
+ with self.assertRaisesRegex(ValueError, "neither a molecule in .* nor a SMILES"):
+ self.relation("C1CC")
+
+ def test_a_parent_given_as_a_molecule(self):
+ record, _, _ = self.relation(h.mol_from_smiles(IBUPROFEN, "lead"))
+ self.assertEqual(record["name"], "lead")
+ record, _, _ = self.relation(Chem.MolFromSmiles(IBUPROFEN))
+ self.assertEqual(record["name"], "parent")
+
+ def test_a_molecule_is_not_its_own_parent(self):
+ self.lead()
+ self.assertEqual(self.relation("ibuprofen", smiles=IBUPROFEN, name="ibuprofen"), (None, None, None))
+
+ def test_a_parent_with_nothing_in_common_has_no_template(self):
+ record, template, query = self.relation("c1ccccc1", smiles="CCO", name="ethanol")
+ self.assertEqual((record["shared_atoms"], template, query), (0, None, None))
+ self.assertEqual(record["changed"], [0, 1, 2])
+
+ def test_a_common_substructure_that_matches_neither_has_no_pairs(self):
+ with mock.patch.object(h, "_mcs", return_value=SimpleNamespace(numAtoms=2, smartsString="[Na][Cl]")):
+ record, template, query = self.relation("CCCCCCO", smiles="CCCCCCN", name="amine")
+ self.assertIsNotNone(query)
+ self.assertEqual((record["shared_atoms"], template), (0, None))
+
+
+@needs_rdkit
+class Describe(Case):
+ def test_the_record_of_a_conformer_ensemble_with_a_pinned_stereocentre(self):
+ mol = h.embed_conformers(h.mol_from_smiles("CC(N)O", "aminoethanol"), n=5)
+ record, svg = h.describe(mol, parent=False, out=self.out, series={"molecules": []})
+ self.assertEqual((record["name"], record["smiles"], record["formula"]), ("aminoethanol", "CC(N)O", "C2H7NO"))
+ self.assertTrue(record["inchikey"])
+ self.assertEqual([(s["atom"], s["label"]) for s in record["stereocentres"]], [(1, "?")])
+ self.assertIn(record["stereocentres"][0]["geometry"], ("R", "S"))
+ self.assertEqual(record["properties"]["unspecified_stereocenters"], 1)
+ count = mol.GetNumConformers()
+ self.assertEqual((record["conformers"]["count"], len(record["conformers"]["energies"])), (count, count))
+ self.assertEqual(record["conformers"]["file"], "aminoethanol.conformers.sdf" if count > 1 else "aminoethanol.sdf")
+ self.assertEqual(record["conformers"]["delta"][0], 0.0)
+ self.assertEqual(len(record["atoms"]), mol.GetNumAtoms())
+ hydrogen = next(a for a in record["atoms"] if a["el"] == "H")
+ self.assertIsNotNone(hydrogen["on"])
+ self.assertIn("<svg", svg)
+ self.assertFalse(record["depiction"]["aligned_to_parent"])
+
+ def test_a_molecule_without_a_name_coordinates_or_series(self):
+ record, _ = h.describe(Chem.MolFromSmiles("CCO"), out=self.out)
+ self.assertEqual((record["name"], record["conformers"]["count"], record["conformers"]["file"]), ("molecule", 0, "molecule.sdf"))
+ self.assertEqual(record["stereocentres"], [])
+ self.assertIsNone(record["parent"])
+
+ def test_a_2d_conformer_has_no_geometry(self):
+ flat = Chem.MolFromSmiles("CC(N)O")
+ h.rdDepictor.Compute2DCoords(flat)
+ record, _ = h.describe(flat, "flat", parent=False, out=self.out, series={"molecules": []})
+ self.assertEqual(record["stereocentres"], [{"atom": 1, "label": "?", "geometry": None}])
+
+ def test_inchi_failures_and_an_odd_valence_do_not_stop_the_record(self):
+ mol = h.embed_3d(h.mol_from_smiles("CC(N)O"))
+ with mock.patch.object(h.Chem, "MolToInchi", side_effect=ValueError("inchi")), \
+ mock.patch.object(h.rdCIPLabeler, "AssignCIPLabels", side_effect=RuntimeError("valence")):
+ record, _ = h.describe(mol, "x", parent=False, out=self.out, series={"molecules": []})
+ self.assertEqual((record["inchi"], record["inchikey"]), (None, None))
+ self.assertIsNotNone(record["stereocentres"][0]["geometry"]) # the legacy label from 3D
+ with mock.patch.object(h.Chem, "MolToInchi", return_value=""):
+ record, _ = h.describe(mol, "x", parent=False, out=self.out, series={"molecules": []})
+ self.assertEqual((record["inchi"], record["inchikey"]), ("", None))
+
+ def test_charges_gasteiger_cannot_assign_and_a_lone_hydride(self):
+ record, _ = h.describe(h.embed_3d(h.mol_from_smiles("C[Se]C")), "se", parent=False, out=self.out, series={"molecules": []})
+ self.assertIsNone(record["atoms"][1]["q"])
+ record, _ = h.describe(Chem.MolFromSmiles("[H-].[Na+]"), "hydride", parent=False, out=self.out, series={"molecules": []})
+ self.assertEqual([(a["el"], a["on"]) for a in record["atoms"]], [("H", None), ("Na", None)])
+
+ def test_conformer_energies_that_do_not_fit_are_dropped(self):
+ mol = h.embed_3d(h.mol_from_smiles("CCO"))
+ mol.SetProp("conformer_energies", "not json")
+ self.assertEqual(h.describe(mol, "x", parent=False, out=self.out, series={"molecules": []})[0]["conformers"]["energies"], [])
+ mol.SetProp("conformer_energies", "[1.0, 2.0]")
+ self.assertEqual(h.describe(mol, "x", parent=False, out=self.out, series={"molecules": []})[0]["conformers"]["delta"], [])
+
+ def test_an_analogue_is_drawn_aligned_to_its_parent_unless_that_fails(self):
+ self.lead()
+ mol = h.embed_3d(h.mol_from_smiles(IBUPROFEN_OH))
+ record, _ = h.describe(mol, "ibuprofen_oh", parent="ibuprofen", out=self.out)
+ self.assertTrue(record["depiction"]["aligned_to_parent"])
+ with mock.patch.object(h.rdDepictor, "GenerateDepictionMatching2DStructure", side_effect=ValueError("no match")):
+ record, _ = h.describe(mol, "ibuprofen_oh", parent="ibuprofen", out=self.out)
+ self.assertFalse(record["depiction"]["aligned_to_parent"])
+ self.assertEqual(len(record["depiction"]["atoms"]), 16)
+
+
+@needs_rdkit
+class WriteOutputs(Case):
+ def test_an_ensemble_writes_every_file_the_pane_and_verdict_read(self):
+ mol = h.embed_conformers(h.mol_from_smiles("CCCC"), n=10)
+ report, printed = quiet(h.write_outputs, mol, "butane", self.out)
+ names = {p.name for p in self.out.iterdir()}
+ self.assertTrue({"butane.sdf", "butane.conformers.sdf", "butane.svg", "butane.png", "butane.molecule.json",
+ "series.json", "properties.json", "report.json", h.PROGRESS} <= names, names)
+ self.assertFalse([n for n in names if n.endswith(".tmp")])
+ self.assertEqual((self.out / "butane.conformers.sdf").read_text().count("$$$$"), 3)
+ sdf = (self.out / "butane.sdf").read_text()
+ self.assertEqual(sdf.count("$$$$"), 1)
+ self.assertIn("> <energy_before>", sdf)
+ record = json.loads((self.out / "butane.molecule.json").read_text())
+ self.assertEqual(record["sdfSha1"], hashlib.sha1(sdf.encode()).hexdigest())
+ self.assertEqual((report["conformers"], report["energies"]["forcefield"], report["parent"]), (3, "MMFF94", None))
+ self.assertEqual(json.loads((self.out / h.PROGRESS).read_text())["stage"], "done")
+ self.assertTrue(printed.startswith(f"{self.out / 'butane.sdf'} · C4H10 · MW 58.12"))
+ self.assertIn("3 conformers · 0 Lipinski violation(s)\n", printed)
+
+ def test_a_single_conformer_removes_a_stale_ensemble(self):
+ self.lead("CCCC", "butane", conformers=10)
+ report = self.lead("CCCC", "butane", conformers=1)
+ self.assertFalse((self.out / "butane.conformers.sdf").exists())
+ self.assertEqual(report["conformers"], 1)
+
+ def test_a_flat_molecule_gets_a_depiction_and_no_sdf(self):
+ report, printed = quiet(h.write_outputs, Chem.MolFromSmiles("CCO"), "flat", self.out)
+ self.assertFalse((self.out / "flat.sdf").exists())
+ self.assertIsNone(report["sdf"])
+ self.assertEqual(report["energies"], {"forcefield": None, "before": None, "final": None})
+ self.assertTrue(printed.startswith(f"{self.out / 'flat.png'} · C2H6O"))
+ self.assertIn("0 conformers", printed)
+
+ def test_an_sdf_without_force_field_facts_carries_only_the_conformer_number(self):
+ mol = Chem.AddHs(Chem.MolFromSmiles("CCO"))
+ AllChem.EmbedMolecule(mol, randomSeed=7)
+ quiet(h.write_outputs, mol, "raw", self.out)
+ tags = [line for line in (self.out / "raw.sdf").read_text().splitlines() if line.startswith(">")]
+ self.assertEqual(tags, ["> <conformer>"])
+
+ def test_sdf_text_skips_energies_it_does_not_have(self):
+ mol = h.embed_conformers(h.mol_from_smiles("CCCC"), n=3)
+ text = h._sdf_text(mol, "butane", [0, 1], [-5.0])
+ first, second = text.split("$$$$\n")[:2]
+ self.assertIn("> <energy>\n-5.0000", first)
+ self.assertNotIn("energy", second)
+ self.assertIn("> <conformer>\n2", second)
+
+ def test_rewriting_a_molecule_keeps_its_place_and_creation_time_in_the_series(self):
+ (self.out / h.SERIES).write_text(json.dumps({"molecules": ["junk", {"name": "old"}, {"name": "ethanol", "createdAt": "2026-01-01T00:00:00Z"}]}))
+ self.lead("CCO", "ethanol")
+ self.lead("CCO", "old")
+ series = json.loads((self.out / h.SERIES).read_text())
+ self.assertEqual([m["name"] for m in series["molecules"]], ["old", "ethanol"])
+ self.assertEqual(series["molecules"][1]["createdAt"], "2026-01-01T00:00:00Z")
+ self.assertEqual(series["molecules"][0]["createdAt"], series["molecules"][0]["updatedAt"])
+ self.assertEqual(series["molecules"][1]["parent"], None)
+
+ def test_an_analogue_says_what_changed_from_its_parent(self):
+ self.lead()
+ mol = h.embed_3d(h.mol_from_smiles(IBUPROFEN_OH))
+ report, printed = quiet(h.write_outputs, mol, "ibuprofen_oh", self.out)
+ self.assertEqual({k: report["parent"][k] for k in ("name", "change", "inferred")}, {"name": "ibuprofen", "change": "+O", "inferred": True})
+ self.assertIn(" · vs ibuprofen: +O, Tanimoto 0.", printed)
+ entry = json.loads((self.out / h.SERIES).read_text())["molecules"][-1]
+ self.assertEqual((entry["parent"], entry["change"]), ("ibuprofen", "+O"))
+
+
+@needs_rdkit
+class Design(Case):
+ def test_design_a_lead_and_its_analogue(self):
+ lead, _ = quiet(h.design, IBUPROFEN, "ibuprofen", out=self.out, conformers=3)
+ self.assertEqual((lead["formula"], lead["parent"]), ("C13H18O2", None))
+ analogue, _ = quiet(h.design, IBUPROFEN_OH, "ibuprofen_oh", out=str(self.out), conformers=1, parent="ibuprofen")
+ self.assertEqual((analogue["parent"]["name"], analogue["parent"]["inferred"], analogue["conformers"]), ("ibuprofen", False, 1))
+
+ def test_a_failed_design_tells_the_pane_and_raises(self):
+ with mock.patch.object(h, "embed_conformers", side_effect=RuntimeError("no 3D embedding for X\nat line 2")), \
+ self.assertRaisesRegex(RuntimeError, "no 3D embedding"):
+ h.design("CCO", "ethanol", out=self.out)
+ self.assertEqual(json.loads((self.out / h.PROGRESS).read_text())["stage"], "failed")
+ self.assertEqual(json.loads((self.out / h.PROGRESS).read_text())["detail"], "no 3D embedding for X")
+
+ def test_a_typo_is_raised_before_any_work(self):
+ with self.assertRaisesRegex(ValueError, "not a valid SMILES"):
+ h.design("C1CC", "typo", out=self.out, conformers=1)
+ self.assertEqual(json.loads((self.out / h.PROGRESS).read_text())["detail"], "1 conformer")
+
+
+@needs_rdkit
+class LoadStructure(Case):
+ def ensemble(self, name="butane", smiles="CCCC", n=10):
+ quiet(h.write_outputs, h.embed_conformers(h.mol_from_smiles(smiles), n=n), name, self.out, parent=False)
+ return self.out / f"{name}.sdf"
+
+ def test_an_sdf_takes_its_ensemble_and_the_energies_written_in_it(self):
+ mol = h.load_structure(self.ensemble())
+ self.assertEqual((mol.GetNumConformers(), mol.GetProp("_Name"), mol.GetProp("forcefield")), (3, "butane", "MMFF94"))
+ energies = json.loads(mol.GetProp("conformer_energies"))
+ self.assertEqual(energies, sorted(energies))
+
+ def test_the_ensemble_itself_loads_as_the_same_molecule(self):
+ self.ensemble()
+ mol = h.load_structure(self.out / "butane.conformers.sdf")
+ self.assertEqual((mol.GetNumConformers(), mol.GetProp("_Name")), (3, "butane"))
+
+ def test_an_ensemble_of_another_molecule_is_ignored_and_foreign_records_are_skipped(self):
+ path = self.ensemble()
+ (self.out / "butane.conformers.sdf").write_text(Chem.MolToMolBlock(h.embed_3d(h.mol_from_smiles("CCO"))) + "$$$$\n")
+ with path.open("a") as sdf:
+ sdf.write(Chem.MolToMolBlock(h.embed_3d(h.mol_from_smiles("CC=C"))) + "$$$$\n") # another molecule after it
+ mol = h.load_structure(path)
+ self.assertEqual(mol.GetNumConformers(), 1)
+
+ def test_energies_stay_with_their_conformers_when_a_foreign_record_sits_between_them(self):
+ butane = h.embed_conformers(h.mol_from_smiles("CCCC"), n=3)
+ ethanol = h.embed_3d(h.mol_from_smiles("CCO"))
+ record = lambda mol, conf, energy: Chem.MolToMolBlock(mol, confId=conf) + f"> <energy>\n{energy}\n\n$$$$\n" # noqa: E731
+ (self.out / "poses.sdf").write_text(record(butane, 0, 1.5) + record(ethanol, 0, 99.0) + record(butane, 1, 2.5))
+ mol = h.load_structure(self.out / "poses.sdf")
+ self.assertEqual(mol.GetNumConformers(), 2)
+ self.assertEqual(json.loads(mol.GetProp("conformer_energies")), [1.5, 2.5])
+
+ def test_missing_or_unreadable_energies_are_computed(self):
+ mol = h.embed_conformers(h.mol_from_smiles("CCCC"), n=3)
+ text = "".join(Chem.MolToMolBlock(mol, confId=c) + "> <energy>\nabc\n\n$$$$\n" for c in range(mol.GetNumConformers()))
+ (self.out / "hand.sd").write_text(text)
+ loaded = h.load_structure(self.out / "hand.sd")
+ self.assertEqual(loaded.GetProp("forcefield"), "MMFF94")
+ self.assertEqual(len(json.loads(loaded.GetProp("conformer_energies"))), 3)
+ with mock.patch.object(h, "_forcefield", side_effect=RuntimeError("no parameters")):
+ self.assertFalse(h.load_structure(self.out / "hand.sd").HasProp("conformer_energies"))
+
+ def test_a_flat_mol_file_has_no_energies(self):
+ flat = Chem.MolFromSmiles("CCO")
+ h.rdDepictor.Compute2DCoords(flat)
+ (self.out / "flat.mol").write_text(Chem.MolToMolBlock(flat))
+ mol = h.load_structure(self.out / "flat.mol")
+ self.assertEqual((mol.GetNumAtoms(), mol.HasProp("conformer_energies"), mol.HasProp("forcefield")), (3, False, False))
+
+ def test_a_pdb_gets_its_bond_orders_perceived_or_keeps_its_connectivity(self):
+ Chem.MolToPDBFile(h.embed_3d(h.mol_from_smiles("CC=O")), str(self.out / "acetaldehyde.pdb"))
+ mol = h.load_structure(self.out / "acetaldehyde.pdb")
+ self.assertEqual(Chem.MolToSmiles(Chem.RemoveHs(mol)), "CC=O")
+ with mock.patch.object(rdDetermineBonds, "DetermineBondOrders", side_effect=ValueError("charge")) as determine:
+ mol = h.load_structure(self.out / "acetaldehyde.pdb")
+ determine.assert_called_once()
+ self.assertEqual((mol.GetNumAtoms(), mol.GetProp("_Name")), (7, "acetaldehyde"))
+
+ def test_a_mol2_file(self):
+ (self.out / "methane.mol2").write_text(METHANE_MOL2)
+ mol = h.load_structure(self.out / "methane.mol2")
+ self.assertEqual((mol.GetNumAtoms(), mol.GetProp("_Name")), (5, "methane"))
+
+ def test_what_rdkit_cannot_read_is_an_error(self):
+ (self.out / "bad.pdb").write_text("nonsense\n")
+ with self.assertRaisesRegex(ValueError, "bad.pdb: no molecule RDKit could sanitize"):
+ h.load_structure(self.out / "bad.pdb")
+ with self.assertRaisesRegex(ValueError, "cannot read .xyz files"):
+ h.load_structure(self.out / "x.xyz")
+
+
+@needs_rdkit
+class Pane(Case):
+ def test_describe_file_for_a_toolchain_sdf_and_a_hand_written_one(self):
+ self.lead("CCCCCCO", "hexanol")
+ record = h.describe_file(self.out / "hexanol.sdf")
+ self.assertEqual((record["name"], record["computedBy"], record["parent"]), ("hexanol", "viewer", None))
+ self.assertIn("<svg", record["svgText"])
+ (self.out / "hand.sdf").write_text(Chem.MolToMolBlock(h.embed_3d(h.mol_from_smiles("CCCCCCN"))) + "$$$$\n")
+ record = h.describe_file(self.out / "hand.sdf")
+ self.assertEqual((record["name"], record["parent"]["name"], record["parent"]["inferred"]), ("hand", "hexanol", True))
+
+ def serve(self, lines):
+ stdin, stdout = io.StringIO("".join(line + "\n" for line in lines)), io.StringIO()
+ with mock.patch.object(sys, "stdin", stdin), mock.patch.object(sys, "stdout", stdout):
+ code = h._serve()
+ return code, [json.loads(line) for line in stdout.getvalue().splitlines()]
+
+ def test_serve_answers_one_line_per_request_and_survives_bad_ones(self):
+ self.lead("CCO", "ethanol")
+ code, replies = self.serve(["", "not json", '{"id": 1, "op": "ping"}', '{"id": 2, "op": "render"}',
+ json.dumps({"id": 3, "op": "describe", "path": str(self.out / "missing.sdf")}),
+ json.dumps({"id": 4, "op": "describe", "path": str(self.out / "ethanol.sdf")})])
+ self.assertEqual(code, 0)
+ self.assertEqual(replies[0], {"id": 1, "ok": True, "result": "pong"})
+ self.assertEqual(replies[1], {"id": 2, "ok": False, "error": "unknown op 'render'"})
+ self.assertEqual((replies[2]["ok"], replies[2]["error"].split(":")[0]), (False, "OSError"))
+ self.assertEqual((replies[3]["id"], replies[3]["ok"], replies[3]["result"]["name"]), (4, True, "ethanol"))
+
+ def test_the_command_line(self):
+ _, printed = quiet(h.main, ["design", "CCO", "ethanol", "--parent", "none", "--conformers", "1", "--out", str(self.out)])
+ self.assertIn("C2H6O", printed)
+ code, printed = quiet(h.main, ["describe", str(self.out / "ethanol.sdf")])
+ self.assertEqual((code, json.loads(printed)["name"]), (0, "ethanol"))
+ with mock.patch.object(sys, "stdin", io.StringIO("")):
+ self.assertEqual(h.main(["serve"]), 0)
+
+ def test_run_as_a_script(self):
+ with mock.patch.object(sys, "argv", ["harness_rdkit.py", "serve"]), mock.patch.object(sys, "stdin", io.StringIO("")), \
+ self.assertRaises(SystemExit) as exit:
+ runpy.run_path(h.__file__, run_name="__main__")
+ self.assertEqual(exit.exception.code, 0)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/store/agents/rdkit/toolchain/test_verdict.py b/store/agents/rdkit/toolchain/test_verdict.py
index 3b93ddffa..311f21571 100644
--- a/store/agents/rdkit/toolchain/test_verdict.py
+++ b/store/agents/rdkit/toolchain/test_verdict.py
@@ -1,8 +1,17 @@
-"""The judge, without RDKit: `python3 -m unittest toolchain/test_verdict.py` on any Python 3.10+."""
-import sys, unittest
+"""The judge, without RDKit: `python3 -m unittest toolchain/test_verdict.py` on any Python 3.10+. The
+tests that read SDFs with RDKit run under "$RDKIT_PYTHON" and skip elsewhere."""
+import contextlib, io, json, os, runpy, sys, tempfile, time, unittest
from pathlib import Path
+from unittest import mock
sys.path.insert(0, str(Path(__file__).parent))
-from verdict import judge
+import verdict
+from verdict import inspect, judge, newest_sdf
+
+try:
+ import rdkit # noqa: F401
+ HAS_RDKIT = True
+except ImportError:
+ HAS_RDKIT = False
REPORT = {"name": "caffeine", "formula": "C8H10N4O2", "atoms": 24, "conformers": 1,
"energies": {"forcefield": "MMFF94", "before": 91.2, "final": 28.4}, "violations": [],
@@ -77,6 +86,151 @@ class Judge(unittest.TestCase):
self.assertTrue(v["summary"].startswith("caffeine_ethyl (+C vs caffeine) · C8H10N4O2"))
self.assertIn("6 conformers", v["summary"])
+ def test_a_report_without_mw_or_logp_leaves_them_out_of_the_summary(self):
+ report = {**REPORT, "properties": {}}
+ v = judge(True, report, SDF)
+ self.assertEqual(v["summary"], "caffeine · C8H10N4O2 · 1 conformer · MMFF94 28.4 kcal/mol")
+
+
+def mol_block(name, atoms, bonds):
+ """A V2000 record: atoms as (symbol, x, y, z), bonds as (a, b) 1-based single bonds."""
+ lines = [name, " example 3D", "", f"{len(atoms):3d}{len(bonds):3d} 0 0 0 0 0 0 0 0999 V2000"]
+ lines += [f"{x:10.4f}{y:10.4f}{z:10.4f} {el:<3} 0 0 0 0 0 0 0 0 0 0 0 0" for el, x, y, z in atoms]
+ lines += [f"{a:3d}{b:3d} 1 0" for a, b in bonds]
+ return "\n".join(lines) + "\nM END\n$$$$\n"
+
+
+WATER_3D = mol_block("water", [("O", 0.0, 0.3664, 0.1), ("H", -0.8123, -0.1835, -0.1), ("H", 0.8131, -0.1829, 0.0)], [(1, 2), (1, 3)])
+WATER_FLAT = mol_block("water", [("O", 0.0, 0.0, 0.0)], [])
+METHANE_3D = mol_block("methane", [("C", 0.0, 0.0, 0.0), ("H", 0.63, 0.63, 0.63), ("H", -0.63, -0.63, 0.63),
+ ("H", -0.63, 0.63, -0.63), ("H", 0.63, -0.63, -0.63)], [(1, 2), (1, 3), (1, 4), (1, 5)])
+
+
+class Workspace(unittest.TestCase):
+ def setUp(self):
+ self.tmp = tempfile.TemporaryDirectory()
+ self.addCleanup(self.tmp.cleanup)
+ self.ws = Path(self.tmp.name).resolve()
+ (self.ws / "out").mkdir()
+ patcher = mock.patch.object(verdict, "WS", self.ws)
+ patcher.start()
+ self.addCleanup(patcher.stop)
+
+ def write(self, rel, text, age=0.0):
+ path = self.ws / rel
+ path.parent.mkdir(parents=True, exist_ok=True)
+ path.write_text(text)
+ stamp = time.time() - age
+ os.utime(path, (stamp, stamp))
+ return path
+
+
+class NewestSdf(Workspace):
+ def test_the_newest_sdf_wins_and_ensembles_and_dotfiles_never_do(self):
+ self.write("out/old.sdf", WATER_3D, age=100)
+ new = self.write("out/series/new.sdf", WATER_3D, age=50)
+ self.write("out/new.conformers.sdf", WATER_3D, age=0)
+ self.write("out/.new.tmp.sdf", WATER_3D, age=0)
+ self.assertEqual(newest_sdf(self.ws), new)
+
+ def test_none_without_an_sdf(self):
+ self.assertIsNone(newest_sdf(self.ws))
+
+
+class InspectWithoutRdkit(Workspace):
+ def test_without_rdkit_a_file_is_only_counted(self):
+ big = self.write("out/big.sdf", WATER_3D)
+ small = self.write("out/small.sdf", "x\n")
+ with mock.patch.dict(sys.modules, {"rdkit": None}):
+ self.assertEqual(inspect(big), {"path": "out/big.sdf", "conformers": 1, "atoms": 0, "error": None})
+ self.assertEqual(inspect(small)["conformers"], 0)
+
+
[email protected](HAS_RDKIT, "RDKit is not installed for this Python")
+class InspectWithRdkit(Workspace):
+ def test_a_3d_record_is_one_conformer_with_its_atoms(self):
+ self.assertEqual(inspect(self.write("out/water.sdf", WATER_3D)),
+ {"path": "out/water.sdf", "conformers": 1, "atoms": 3, "error": None})
+
+ def test_the_ensemble_beside_it_is_counted(self):
+ path = self.write("out/water.sdf", WATER_3D)
+ self.write("out/water.conformers.sdf", WATER_3D * 4)
+ self.assertEqual(inspect(path)["conformers"], 4)
+
+ def test_an_ensemble_of_another_molecule_is_not_counted(self):
+ path = self.write("out/water.sdf", WATER_3D)
+ self.write("out/water.conformers.sdf", METHANE_3D * 3)
+ self.assertEqual(inspect(path)["conformers"], 1)
+
+ def test_a_flat_record_has_no_conformer_and_no_parse_error(self):
+ info = inspect(self.write("out/water.sdf", WATER_FLAT))
+ self.assertEqual((info["conformers"], info["atoms"], info["error"]), (0, 1, None))
+
+ def test_a_file_rdkit_cannot_sanitize_is_an_error(self):
+ info = inspect(self.write("out/bad.sdf", "not a molecule\n"))
+ self.assertEqual(info["error"], "no molecule RDKit could sanitize")
+
+ def test_a_file_rdkit_cannot_open_is_an_error_not_a_crash(self):
+ folder = self.ws / "out" / "folder.sdf"
+ folder.mkdir()
+ info = inspect(folder)
+ self.assertEqual(info["conformers"], 0)
+ self.assertIn("folder.sdf", info["error"])
+
+
+class Main(Workspace):
+ def run_main(self, argv):
+ stdout = io.StringIO()
+ with contextlib.redirect_stdout(stdout):
+ code = verdict.main(argv)
+ return code, stdout.getvalue(), json.loads((self.ws / ".harness" / "verdict.json").read_text())
+
+ def test_an_empty_workspace_is_not_ready(self):
+ code, out, v = self.run_main(["verdict.py"])
+ self.assertEqual(code, 1)
+ self.assertEqual(out, "not ready · no design yet\n")
+ self.assertEqual(v["summary"], "no design yet")
+
+ def test_a_designed_molecule_is_ready_and_its_findings_are_printed(self):
+ self.write("molecules/water.py", "print('water')\n")
+ self.write("out/report.json", json.dumps({**REPORT, "name": "water", "atoms": 3, "violations": ["mw 612 > 500"]}))
+ self.write("out/water.sdf", WATER_3D)
+ code, out, v = self.run_main(["verdict.py"])
+ self.assertEqual(code, 0)
+ self.assertTrue(out.startswith("ready · water · C8H10N4O2"), out)
+ self.assertIn(" warning Lipinski: mw 612 > 500\n", out)
+ self.assertEqual(v["artifact"], "out/water.sdf")
+
+ def test_a_smi_list_is_a_design_and_a_torn_report_is_no_report(self):
+ self.write("molecules/series.smi", "CCO ethanol\n")
+ self.write("out/report.json", '{"name": ')
+ code, _, v = self.run_main(["verdict.py"])
+ self.assertEqual((code, v["summary"]), (1, "no molecule yet"))
+
+ def test_a_named_sdf_is_judged_instead_of_the_newest(self):
+ self.write("molecules/water.py", "")
+ self.write("out/report.json", json.dumps(REPORT))
+ named = self.write("out/named.sdf", WATER_3D, age=100)
+ self.write("out/newer.sdf", WATER_3D)
+ code, _, v = self.run_main(["verdict.py", str(named)])
+ self.assertEqual((code, v["artifact"]), (0, "out/named.sdf"))
+
+ def test_a_named_sdf_that_is_missing_is_judged_as_none(self):
+ self.write("molecules/water.py", "")
+ self.write("out/report.json", json.dumps(REPORT))
+ code, _, v = self.run_main(["verdict.py", str(self.ws / "out" / "gone.sdf")])
+ self.assertEqual((code, v["phases"][1]["state"]), (1, "active"))
+
+ def test_run_as_a_script_it_judges_harness_workspace(self):
+ stdout = io.StringIO()
+ with mock.patch.dict(os.environ, {"HARNESS_WORKSPACE": str(self.ws)}), \
+ mock.patch.object(sys, "argv", ["verdict.py"]), contextlib.redirect_stdout(stdout), \
+ self.assertRaises(SystemExit) as exit:
+ runpy.run_path(verdict.__file__, run_name="__main__")
+ self.assertEqual(exit.exception.code, 1)
+ self.assertEqual(stdout.getvalue(), "not ready · no design yet\n")
+ self.assertTrue((self.ws / ".harness" / "verdict.json").is_file())
+
if __name__ == "__main__":
unittest.main()