def test_alanine(self):
compound = smiles_to_compound("N[C@H](C)C(=O)O")
self.assertCountEqual(compound.neighbors(2), [1, 3, 4, 5])
self.assertEqual(compound.atom(2).stereo, 1)
compound = smiles_to_compound("N[C@@H](C)C(=O)O")
self.assertCountEqual(compound.neighbors(2), [1, 3, 4, 5])
self.assertEqual(compound.atom(2).stereo, -1)
def test_iron2_cation(self):
compound = smiles_to_compound("[Fe++]")
self.assertEqual(compound.atom(1).symbol, 'Fe')
self.assertEqual(compound.atom(1).charge, 2)
compound = smiles_to_compound("[Fe+2]")
self.assertEqual(compound.atom(1).symbol, 'Fe')
self.assertEqual(compound.atom(1).charge, 2)
def test_bicyclohexyl(self):
compound = smiles_to_compound("C1CCCCC1C1CCCCC1")
self.assertEqual(compound.bond(1, 6).order, 1)
self.assertEqual(compound.bond(7, 12).order, 1)
compound = smiles_to_compound("C1CCCCC1C2CCCCC2")
self.assertEqual(compound.bond(1, 6).order, 1)
self.assertEqual(compound.bond(7, 12).order, 1)
def test_naphthalene(self):
compound = smiles_to_compound("C=1C=CC=C2C1C=CC=C2")
self.assertEqual(compound.bond(1, 6).order, 2)
self.assertEqual(compound.bond(5, 10).order, 1)
compound = smiles_to_compound("C1=CC=C2C(=C1)C=CC=C2")
self.assertEqual(compound.bond(1, 6).order, 1)
self.assertEqual(compound.bond(4, 10).order, 1)
def test_assign_pai(self):
mol = smiles_to_compound("CC=CC#C")
self.assertEqual([a.pi for _, a in mol.atoms_iter()], [0, 1, 1, 2, 2])
mol = smiles_to_compound("C1=CC=CN1")
self.assertEqual([a.pi for _, a in mol.atoms_iter()], [1, 1, 1, 1, 0])
mol = smiles_to_compound("CC(=O)N=N=N")
self.assertEqual([a.pi for _, a in mol.atoms_iter()],
[0, 1, 1, 1, 2, 1])
def test_formula(self):
mol = reader.mol_from_text(MOL["Phe"])
self.assertEqual(molutil.formula(mol), "C9H11NO2")
mol = reader.mol_from_text(MOL["KCl"])
self.assertEqual(molutil.formula(mol), "Cl.K") # longer text first
mol = smiles_to_compound("CCO.O.O")
self.assertEqual(molutil.formula(mol), "C2H6O.2H2O")
mol = smiles_to_compound("CCCSCC(Cl)C(O)O")
self.assertEqual(molutil.formula(mol), "C6H13O2SCl")
def test_cyclohexene(self):
compound = smiles_to_compound("C1C=CCCC1")
self.assertCountEqual(compound.neighbors(1), [2, 6])
self.assertEqual(compound.bond(2, 3).order, 2)
compound = smiles_to_compound("C=1CCCCC1")
self.assertCountEqual(compound.neighbors(1), [2, 6])
self.assertEqual(compound.bond(1, 6).order, 2)
compound = smiles_to_compound("C1CCCCC=1")
self.assertCountEqual(compound.neighbors(1), [2, 6])
self.assertEqual(compound.bond(1, 6).order, 2)
def test_assign_hydrogen(self):
mol = smiles_to_compound("CCC(=O)N")
self.assertTrue(mol.atom(4).H_acceptor)
self.assertTrue(mol.atom(5).H_donor)
self.assertTrue(mol.atom(5).H_acceptor)
mol = smiles_to_compound("CCN(CO)CF")
self.assertFalse(mol.atom(3).H_donor)
self.assertTrue(mol.atom(5).H_donor)
self.assertTrue(mol.atom(5).H_acceptor)
self.assertTrue(mol.atom(7).H_acceptor)
def test_mcsdr2(self):
# Disconnected
mol1 = smiles_to_compound("C1CCCC1CCCC(=O)O")
mol2 = reader.mol_from_text(MOL["CaAcO2"])
arr1 = mcsdr.DescriptorArray(mol1)
arr2 = mcsdr.DescriptorArray(mol2)
self.assertEqual(mcsdr.from_array(arr1, arr2).edge_count(), 3)
# No line graph
mol1 = smiles_to_compound("CO")
mol2 = smiles_to_compound("CC")
arr1 = mcsdr.DescriptorArray(mol1)
arr2 = mcsdr.DescriptorArray(mol2)
self.assertEqual(mcsdr.from_array(arr1, arr2).edge_count(), 0)
# TODO: minimum MCS edge size is 2
mol1 = smiles_to_compound("CCO")
mol2 = smiles_to_compound("CCC")
arr1 = mcsdr.DescriptorArray(mol1)
arr2 = mcsdr.DescriptorArray(mol2)
self.assertEqual(mcsdr.from_array(arr1, arr2).edge_count(), 0)
# This works well
mol1 = smiles_to_compound("CCCO")
mol2 = smiles_to_compound("CCCC")
arr1 = mcsdr.DescriptorArray(mol1)
arr2 = mcsdr.DescriptorArray(mol2)
self.assertEqual(mcsdr.from_array(arr1, arr2).edge_count(), 2)
# TODO: pitfall in line graph
mol1 = smiles_to_compound("CO(C)(C)C")
mol2 = smiles_to_compound("OC(O)(O)O")
arr1 = mcsdr.DescriptorArray(mol1)
arr2 = mcsdr.DescriptorArray(mol2)
def test_substructure(self):
mol = smiles_to_compound("c1ccccc1")
query = smiles_to_compound("c1ccccc1CCC")
qj = json.dumps(query.jsonized())[:1000]
self.assertTrue(substructure(mol, query))
mol = smiles_to_compound("c1ccccc1.CCO.O.O")
mj = json.dumps(mol.jsonized())[:1000]
self.assertTrue(substructure(mol, query))
self.assertFalse(substructure(mol, query, largest_only=False))
# Non destructive
self.assertEqual(mj, json.dumps(mol.jsonized())[:1000])
self.assertEqual(qj, json.dumps(query.jsonized())[:1000])
def test_mcsdr1(self):
# TODO: pi mismatch is not acceptable
mol1 = reader.mol_from_text(MOL["Phe"])
mol2 = reader.mol_from_text(MOL["Arg"])
arr1 = mcsdr.DescriptorArray(mol1)
arr2 = mcsdr.DescriptorArray(mol2)
self.assertEqual(mcsdr.from_array(arr1, arr2).edge_count(), 5)
# Delta-y exchange will not occur due to distance descriptor
mol1 = smiles_to_compound("C1OC1CCC(=O)O")
mol2 = smiles_to_compound("CC(O)CCC(=O)O")
arr1 = mcsdr.DescriptorArray(mol1)
arr2 = mcsdr.DescriptorArray(mol2)
self.assertEqual(mcsdr.from_array(arr1, arr2).edge_count(), 7)
def test_mcsdr2(self):
# Disconnected
mol1 = smiles_to_compound("C1CCCC1CCCC(=O)O")
mol2 = reader.mol_from_text(MOL["CaAcO2"])
arr1 = mcsdr.comparison_array(mol1)
arr2 = mcsdr.comparison_array(mol2)
self.assertEqual(mcsdr.local_sim(arr1, arr2)["mcsdr_edges"], 3)
# No line graph
mol1 = smiles_to_compound("CO")
mol2 = smiles_to_compound("CC")
arr1 = mcsdr.comparison_array(mol1)
arr2 = mcsdr.comparison_array(mol2)
self.assertEqual(mcsdr.local_sim(arr1, arr2)["mcsdr_edges"], 0)
def test_wcpaper(self):
""" Wildman and Crippen 1999, Table.2 """
mol = smiles_to_compound("C=1C=CC=C(OC)C=1O")
wclogp.assign_wctype(mol)
self.assertEqual([a.wctype for _, a in mol.atoms_iter()],
["C18", "C18", "C18", "C18", "C23",
"O4", "C3", "C23", "O2"])
self.assertEqual(wclogp.wclogp(mol), 1.40)
self.assertEqual(wclogp.wcmr(mol), 34.66)
mol = smiles_to_compound("C1=CC=CC=C1C2=CC=CC=N2")
wclogp.assign_wctype(mol)
self.assertEqual([a.wctype for _, a in mol.atoms_iter()],
["C18", "C18", "C18", "C18", "C18", "C20",
"C20", "C18", "C18", "C18", "C18", "N11"])
self.assertEqual(wclogp.wclogp(mol), 2.75)
self.assertEqual(wclogp.wcmr(mol), 49.67)
def test_minify_ring(self):
# Cyanocobalamin
mol = reader.mol_from_text(MOL["Cyanocobalamin"])
self.assertEqual(Counter([len(r) for r in mol.rings]), {
5: 7,
6: 4,
19: 1
})
# Rifabutin
# TODO: this can be [5, 5, 6, 6, 6, 25] or [5, 5, 6, 6, 6, 24]
# mol = reader.mol_from_text(MOL["Rifabutin"])
# self.assertEqual(sorted([len(r) for r in mol.rings]),
# [5, 5, 6, 6, 6, 24])
# Cubane
mol = smiles_to_compound("C12C3C4C1C5C4C3C25")
self.assertEqual(Counter([len(r) for r in mol.rings]), {4: 5})
# Pinene
mol = smiles_to_compound("CC1(C2CCC(=C)C1C2)C")
self.assertEqual(Counter([len(r) for r in mol.rings]), {4: 1, 6: 1})
def test_coords(self):
# mol = reader.mol_from_text(MOL["Phe"])
# TODO: without scaffold (Linoleic acid)
mol = smilessupplier.smiles_to_compound("CCCCCC=CCC=CCCCCCCCC(=O)O")
# mol = reader.mol_from_text(MOL["KCl"]) # TODO: overlap
# mol = reader.mol_from_text(MOL["Carbidopa"]) # TODO: quart overlap
# mol = reader.mol_from_text(MOL["Formestane"]) # TODO: overlap
# mol = reader.mol_from_text(MOL["Ceftazidime"]) # TODO: overlap
# mol = reader.mol_from_text(MOL["Daunorubicin"]) # TODO: quart overlap
# mol = reader.mol_from_text(MOL["Paclitaxel"]) # TODO: overlap
# mol = reader.mol_from_text(MOL["Spinosad"]) # TODO: overlap
calc2dcoords.calc2dcoords(mol)
self.draw_test(mol)
def test_recognize(self):
# Phenylalanin
mol = reader.mol_from_text(MOL["Phe"])
self.assertTrue(
self.equivalent_ring(mol.rings[0], [8, 11, 12, 10, 7, 6]))
self.assertEqual(mol.scaffolds, [[0]])
self.assertEqual(mol.isolated, [])
# Premarin
mol = reader.mol_from_text(MOL["Premarin"])
for a, b in zip(
sorted(mol.rings),
sorted([[10, 9, 8, 7, 4, 5], [10, 14, 13, 12, 11, 9],
[24, 25, 26, 12, 11], [2, 3, 4, 5, 6, 1]])):
self.assertTrue(self.equivalent_ring(a, b))
self.assertEqual(mol.scaffolds, [[0, 1, 2, 3]])
self.assertEqual(mol.isolated, [[28]])
# Pyrene
mol = smiles_to_compound("C12=CC=C3C=CC=C4C=CC(C2=C34)=CC=C1")
self.assertEqual([len(r) for r in mol.rings], [6, 6, 6, 6])
self.assertEqual(mol.scaffolds, [[0, 1, 2, 3]])
self.assertEqual(mol.isolated, [])
# KCl
mol = reader.mol_from_text(MOL["KCl"])
self.assertEqual(mol.rings, [])
self.assertEqual(mol.scaffolds, [])
self.assertEqual(mol.isolated, [[2]])
# Goserelin
mol = reader.mol_from_text(MOL["Goserelin"])
self.assertEqual(sorted([len(r) for r in mol.rings]),
[5, 5, 5, 5, 6, 6])
self.assertEqual(Counter([len(s) for s in mol.scaffolds]), {
1: 4,
2: 1
})
# Tetrahedrane (K4 graph)
mol = smiles_to_compound("C12C3C1C23")
self.assertEqual([len(r) for r in mol.rings], [3, 3, 3])
def test_total_size(self):
# TODO: memory size depends on the implementation
# 64 bit
self.assertEqual(debug.total_size(0), 24)
self.assertEqual(debug.total_size([]), 64)
self.assertEqual(debug.total_size([1, 2, 3]), 172)
# Empty dict size: Python3.5 -> 288, Python3.6 -> 240
self.assertEqual(debug.total_size({}), 240)
# Python3.5 -> 471, Python3.6 -> 423
self.assertEqual(debug.total_size({"hoge": "fuga", "piyo": 0}), 423)
self.assertEqual(debug.total_size(((1, 2), (3, 4))), 304)
# Python3.5 -> 2662, Python3.6 -> 2470
self.assertEqual(debug.total_size(Compound()), 2470)
c = smiles_to_compound("C1CCCCC1CNC=O")
# Python3.5 -> 16530, Python3.6 -> 15330
self.assertEqual(debug.total_size(c), 15330)
def test_scale_and_center(self):
m2 = reader.mol_from_text(MOL["Goserelin"])
helper.scale_and_center(m2)
self.assertAlmostEqual(m2.size2d[0], 15.21, 2)
self.assertAlmostEqual(m2.size2d[1], 16.06, 2)
self.assertAlmostEqual(m2.size2d[2], 0.83, 2)
m3 = reader.mol_from_text(MOL["KCl"])
helper.scale_and_center(m3)
self.assertAlmostEqual(m3.size2d[0], 1.0, 2)
self.assertAlmostEqual(m3.size2d[1], 0, 2)
self.assertAlmostEqual(m3.size2d[2], 0.71, 2)
m = smilessupplier.smiles_to_compound("[K+].[Cl-]") # TODO: overlap
calc2dcoords.calc2dcoords(m)
helper.scale_and_center(m)
self.assertAlmostEqual(m.size2d[0], 0, 2)
self.assertAlmostEqual(m.size2d[1], 0, 2)
self.assertAlmostEqual(m.size2d[2], 1, 2)
def test_filter(self):
query = smiles_to_compound("c1ccccc1C2CCC2C")
mol = smiles_to_compound("c1ccccc1C2CCC2")
self.assertFalse(filter_(mol, query))
mol = smiles_to_compound("c1ccccc1C2CC=C2C")
self.assertFalse(filter_(mol, query))
mol = smiles_to_compound("c1ccccc1C2CC2CC")
self.assertFalse(filter_(mol, query))
mol = smiles_to_compound("c1cccc2c1CC2CCC")
self.assertFalse(filter_(mol, query))
mol = smiles_to_compound("c1ccccc1C2CC(C)C2")
self.assertTrue(filter_(mol, query))
def test_assign_aromatic(self):
# Furan is aromatic
mol = smiles_to_compound("O1C=CC=C1")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[1, 1, 1, 1, 1])
# Quinone is not aromatic
mol = smiles_to_compound("C1(=O)C=CC(=O)C=C1")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[0, 0, 0, 0, 0, 0, 0, 0])
# Tropone is aromatic
mol = smiles_to_compound("C1(=O)C=CC=CC=C1")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[1, 0, 1, 1, 1, 1, 1, 1])
# Azepine is not aromatic
mol = smiles_to_compound("N1C=CC=CC=C1")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[0, 0, 0, 0, 0, 0, 0])
# 1,2-Dihydro-1,2-azaborine is aromatic
mol = smiles_to_compound("C1=CC=CBN1")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[1, 1, 1, 1, 1, 1])
# Fulvene is not aromatic
mol = smiles_to_compound("C1=CC=CC1=C")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[0, 0, 0, 0, 0, 0])
# Cyclopropenyl cation is aromatic
mol = smiles_to_compound("C1=C[C+]1")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()], [1, 1, 1])
# 1,3,5-Hexatriene is not aromatic
mol = smiles_to_compound("C=CC=CC=C")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[0, 0, 0, 0, 0, 0])
# Borazine is aromatic
mol = smiles_to_compound("B1NBNBN1")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[1, 1, 1, 1, 1, 1])
# 1,2-Methylenedioxybenzene is not aromatic
mol = smiles_to_compound("C1=CC=CC2=C1OCO2")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[1, 1, 1, 1, 1, 1, 0, 0, 0])
# Naphthalene is aromatic
mol = smiles_to_compound("C=1C=CC=C2C1C=CC=C2")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
# Coumarin is aromatic
mol = smiles_to_compound("C1=CC(=O)OC2=C1C=CC=C2")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1])
# Pyrene is aromatic
mol = smiles_to_compound("C12=CC=C3C=CC=C4C=CC(C2=C34)=CC=C1")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
# Caffeine is aromatic
mol = smiles_to_compound("CN1C=NC2=C1C(=O)N(C)C(=O)N2C")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0])
# Pyromellitimide is not aromatic
mol = smiles_to_compound("C1(=O)NC(=O)C=2C1=CC=3C(=O)NC(=O)C=3C=2")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1])
# TODO: Azulene is not aromatic
mol = smiles_to_compound("C=1C=CC=2C1C=CC=CC2")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
# TODO: o-Quinodimethane is aromatic
mol = smiles_to_compound("C1=CC=CC(=C)C1(=C)")
self.assertEqual([a.aromatic for _, a in mol.atoms_iter()],
[1, 1, 1, 1, 1, 0, 1, 0])
def test_t_butyl_alchol(self):
compound = smiles_to_compound("CC(C)(C)O")
self.assertEqual(compound.atom(5).symbol, 'O')
self.assertCountEqual(compound.neighbors(2), [1, 3, 4, 5])
def test_trifluoroacetic_acid(self):
compound = smiles_to_compound("FC(F)(F)C(=O)O")
self.assertEqual(compound.bond(5, 6).order, 2)
self.assertCountEqual(compound.neighbors(2), [1, 3, 4, 5])
def test_remove_salt(self):
mol = ss.smiles_to_compound("CC[O-].[Na+]")
remover.remove_salt(mol)
self.assertEqual(len(mol), 3)
def test_remove_water(self):
mol = ss.smiles_to_compound("CCO.O.O")
remover.remove_water(mol)
self.assertEqual(len(mol), 3)
def test_vinylchloride(self):
compound = smiles_to_compound("C=CCl")
self.assertEqual(compound.bond(1, 2).order, 2)
self.assertEqual(compound.atom(3).symbol, 'Cl')
def test_edta(self):
compound = smiles_to_compound("C(CN(CC(=O)O)CC(=O)O)N(CC(=O)O)CC(=O)O")
self.assertCountEqual(compound.neighbors(5), [4, 6, 7])
self.assertCountEqual(compound.neighbors(12), [1, 13, 17])
self.assertCountEqual(compound.neighbors(14), [13, 15, 16])
def test_ethanol(self):
compound = smiles_to_compound("CCO")
self.assertEqual(compound.atom_count(), 3)
compound = smiles_to_compound("[CH3][CH2][OH]")
self.assertEqual(compound.atom_count(), 3)
def test_nacl(self):
compound = smiles_to_compound("[Na+].[Cl-]")
self.assertEqual(compound.atom(1).symbol, 'Na')
self.assertEqual(compound.atom(1).charge, 1)
self.assertEqual(compound.atom(2).symbol, 'Cl')
self.assertEqual(compound.atom(2).charge, -1)
def draw_chain(self, res):
mol = smilessupplier.smiles_to_compound("C" * len(res))
for k, a in mol.atoms_iter():
mol.atom(k).coords = res[k - 1][:2]
svg = SVG(mol)
svg.save("_test_result.svg")
def test_nitrogen(self):
compound = smiles_to_compound("N#N")
self.assertEqual(compound.atom(2).symbol, 'N')
self.assertEqual(compound.bond(1, 2).order, 3)
