diff --git a/modules/mol/alg/tests/test_ligand_scoring.py b/modules/mol/alg/tests/test_ligand_scoring.py
index 4a13ed256791414323e3d72551f231b2f5159930..877bfa6eb68af9a41c4c09c39b419244acedd0b5 100644
--- a/modules/mol/alg/tests/test_ligand_scoring.py
+++ b/modules/mol/alg/tests/test_ligand_scoring.py
@@ -51,10 +51,10 @@ class TestLigandScoring(unittest.TestCase):
sc = LigandScorer(mdl, trg, None, None)
- assert len(sc.target_ligands) == 7
- assert len(sc.model_ligands) == 1
- assert len([r for r in sc.target.residues if r.is_ligand]) == 7
- assert len([r for r in sc.model.residues if r.is_ligand]) == 1
+ self.assertEqual(len(sc.target_ligands), 7)
+ self.assertEqual(len(sc.model_ligands), 1)
+ self.assertEqual(len([r for r in sc.target.residues if r.is_ligand]), 7)
+ self.assertEqual(len([r for r in sc.model.residues if r.is_ligand]), 1)
def test_init_given_ligands(self):
"""Test that we can instantiate the scorer with ligands contained in
@@ -68,29 +68,29 @@ class TestLigandScoring(unittest.TestCase):
mdl_lig = [mdl.Select("rname=G3D")]
sc = LigandScorer(mdl, trg, mdl_lig, trg_lig)
- assert len(sc.target_ligands) == 4
- assert len(sc.model_ligands) == 1
+ self.assertEqual(len(sc.target_ligands), 4)
+ self.assertEqual(len(sc.model_ligands), 1)
# IsLigand flag should still be set even on not selected ligands
- assert len([r for r in sc.target.residues if r.is_ligand]) == 7
- assert len([r for r in sc.model.residues if r.is_ligand]) == 1
+ self.assertEqual(len([r for r in sc.target.residues if r.is_ligand]), 7)
+ self.assertEqual(len([r for r in sc.model.residues if r.is_ligand]), 1)
# Ensure the residues are not copied
- assert len(sc.target.Select("rname=MG").residues) == 2
- assert len(sc.target.Select("rname=G3D").residues) == 2
- assert len(sc.model.Select("rname=G3D").residues) == 1
+ self.assertEqual(len(sc.target.Select("rname=MG").residues), 2)
+ self.assertEqual(len(sc.target.Select("rname=G3D").residues), 2)
+ self.assertEqual(len(sc.model.Select("rname=G3D").residues), 1)
# Pass residue handles
trg_lig = [trg.FindResidue("F", 1), trg.FindResidue("H", 1)]
mdl_lig = [mdl.FindResidue("L_2", 1)]
sc = LigandScorer(mdl, trg, mdl_lig, trg_lig)
- assert len(sc.target_ligands) == 2
- assert len(sc.model_ligands) == 1
+ self.assertEqual(len(sc.target_ligands), 2)
+ self.assertEqual(len(sc.model_ligands), 1)
# Ensure the residues are not copied
- assert len(sc.target.Select("rname=ZN").residues) == 1
- assert len(sc.target.Select("rname=G3D").residues) == 2
- assert len(sc.model.Select("rname=G3D").residues) == 1
+ self.assertEqual(len(sc.target.Select("rname=ZN").residues), 1)
+ self.assertEqual(len(sc.target.Select("rname=G3D").residues), 2)
+ self.assertEqual(len(sc.model.Select("rname=G3D").residues), 1)
def test_init_sdf_ligands(self):
"""Test that we can instantiate the scorer with ligands from separate SDF files.
@@ -116,11 +116,11 @@ class TestLigandScoring(unittest.TestCase):
# Pass entities
sc = LigandScorer(mdl, trg, mdl_ligs, trg_ligs)
- assert len(sc.target_ligands) == 7
- assert len(sc.model_ligands) == 1
+ self.assertEqual(len(sc.target_ligands), 7)
+ self.assertEqual(len(sc.model_ligands), 1)
# Ensure we set the is_ligand flag
- assert len([r for r in sc.target.residues if r.is_ligand]) == 7
- assert len([r for r in sc.model.residues if r.is_ligand]) == 1
+ self.assertEqual(len([r for r in sc.target.residues if r.is_ligand]), 7)
+ self.assertEqual(len([r for r in sc.model.residues if r.is_ligand]), 1)
# Pass residues
mdl_ligs_res = [mdl_ligs[0].residues[0]]
@@ -128,8 +128,8 @@ class TestLigandScoring(unittest.TestCase):
sc = LigandScorer(mdl, trg, mdl_ligs_res, trg_ligs_res)
- assert len(sc.target_ligands) == 7
- assert len(sc.model_ligands) == 1
+ self.assertEqual(len(sc.target_ligands), 7)
+ self.assertEqual(len(sc.model_ligands), 1)
def test_init_reject_duplicate_ligands(self):
"""Test that we reject input if multiple ligands with the same chain
@@ -159,16 +159,16 @@ class TestLigandScoring(unittest.TestCase):
mdl_lig = _LoadEntity("P84080_model_02_ligand_0.sdf")
graph = ligand_scoring._ResidueToGraph(mdl_lig.residues[0])
- assert len(graph.edges) == 34
- assert len(graph.nodes) == 32
+ self.assertEqual(len(graph.edges), 34)
+ self.assertEqual(len(graph.nodes), 32)
# Check an arbitrary node
- assert [a for a in graph.adj["14"].keys()] == ["13", "29"]
+ self.assertEqual([a for a in graph.adj["14"].keys()], ["13", "29"])
graph = ligand_scoring._ResidueToGraph(mdl_lig.residues[0], by_atom_index=True)
- assert len(graph.edges) == 34
- assert len(graph.nodes) == 32
+ self.assertEqual(len(graph.edges), 34)
+ self.assertEqual(len(graph.nodes), 32)
# Check an arbitrary node
- assert [a for a in graph.adj[13].keys()] == [12, 28]
+ self.assertEqual([a for a in graph.adj[13].keys()], [12, 28])
def test__ComputeSymmetries(self):
"""Test that _ComputeSymmetries works.
@@ -183,15 +183,15 @@ class TestLigandScoring(unittest.TestCase):
mdl_g3d = mdl.FindResidue("L_2", 1)
sym = ligand_scoring._ComputeSymmetries(mdl_g3d, trg_g3d1)
- assert len(sym) == 72
+ self.assertEqual(len(sym), 72)
sym = ligand_scoring._ComputeSymmetries(mdl_g3d, trg_g3d1, by_atom_index=True)
- assert len(sym) == 72
+ self.assertEqual(len(sym), 72)
# Test that we can match ions read from SDF
sdf_lig = _LoadEntity("1r8q_ligand_0.sdf")
sym = ligand_scoring._ComputeSymmetries(trg_mg1, sdf_lig.residues[0], by_atom_index=True)
- assert len(sym) == 1
+ self.assertEqual(len(sym), 1)
# Test that it works with views and only consider atoms in the view
# Skip PA, PB and O[1-3]A and O[1-3]B in target and model
@@ -202,14 +202,14 @@ class TestLigandScoring(unittest.TestCase):
mdl_g3d_sub = mdl_g3d_sub_ent.residues[0]
sym = ligand_scoring._ComputeSymmetries(mdl_g3d_sub, trg_g3d1_sub)
- assert len(sym) == 6
+ self.assertEqual(len(sym), 6)
sym = ligand_scoring._ComputeSymmetries(mdl_g3d_sub, trg_g3d1_sub, by_atom_index=True)
- assert len(sym) == 6
+ self.assertEqual(len(sym), 6)
# Substructure matches
sym = ligand_scoring._ComputeSymmetries(mdl_g3d, trg_g3d1_sub, substructure_match=True)
- assert len(sym) == 6
+ self.assertEqual(len(sym), 6)
# Missing atoms only allowed in target, not in model
with self.assertRaises(NoSymmetryError):
@@ -272,7 +272,7 @@ class TestLigandScoring(unittest.TestCase):
sc._compute_scores()
# Check RMSD
- assert sc.rmsd_matrix.shape == (7, 1)
+ self.assertEqual(sc.rmsd_matrix.shape, (7, 1))
np.testing.assert_almost_equal(sc.rmsd_matrix, np.array(
[[np.nan],
[0.04244993],
@@ -372,23 +372,23 @@ class TestLigandScoring(unittest.TestCase):
# Local by default
sc = LigandScorer(mdl, trg, None, None)
- assert sc.rmsd_details["L_2"][1]["chain_mapping"] == {'A': 'A'}
- assert sc.lddt_pli_details["L_2"][1]["chain_mapping"] == {'C': 'A'}
+ self.assertEqual(sc.rmsd_details["L_2"][1]["chain_mapping"], {'A': 'A'})
+ self.assertEqual(sc.lddt_pli_details["L_2"][1]["chain_mapping"], {'C': 'A'})
# Global
sc = LigandScorer(mdl, trg, None, None, global_chain_mapping=True)
- assert sc.rmsd_details["L_2"][1]["chain_mapping"] == {'C': 'A'}
- assert sc.lddt_pli_details["L_2"][1]["chain_mapping"] == {'C': 'A'}
+ self.assertEqual(sc.rmsd_details["L_2"][1]["chain_mapping"], {'C': 'A'})
+ self.assertEqual(sc.lddt_pli_details["L_2"][1]["chain_mapping"], {'C': 'A'})
# Custom
sc = LigandScorer(mdl, trg, None, None, global_chain_mapping=True, custom_mapping={'A': 'A'})
- assert sc.rmsd_details["L_2"][1]["chain_mapping"] == {'A': 'A'}
- assert sc.lddt_pli_details["L_2"][1]["chain_mapping"] == {'A': 'A'}
+ self.assertEqual(sc.rmsd_details["L_2"][1]["chain_mapping"], {'A': 'A'})
+ self.assertEqual(sc.lddt_pli_details["L_2"][1]["chain_mapping"], {'A': 'A'})
# Custom only active with global chain mapping
sc = LigandScorer(mdl, trg, None, None, global_chain_mapping=False, custom_mapping={'A': 'A'})
- assert sc.rmsd_details["L_2"][1]["chain_mapping"] == {'A': 'A'}
- assert sc.lddt_pli_details["L_2"][1]["chain_mapping"] == {'C': 'A'}
+ self.assertEqual(sc.rmsd_details["L_2"][1]["chain_mapping"], {'A': 'A'})
+ self.assertEqual(sc.lddt_pli_details["L_2"][1]["chain_mapping"], {'C': 'A'})
def test_rmsd_assignment(self):
"""Test that the RMSD-based assignment works.
@@ -407,7 +407,7 @@ class TestLigandScoring(unittest.TestCase):
# RMSD assignment forces the same assignment
sc = LigandScorer(mdl, trg, None, None, rmsd_assignment=True)
- assert sc.rmsd_details["L_2"][1]["target_ligand"] == sc.lddt_pli_details["L_2"][1]["target_ligand"]
+ self.assertEqual(sc.rmsd_details["L_2"][1]["target_ligand"], sc.lddt_pli_details["L_2"][1]["target_ligand"])
def test_ignore_binding_site(self):
"""Test that we ignore non polymer stuff in the binding site.
@@ -419,7 +419,7 @@ class TestLigandScoring(unittest.TestCase):
sc = LigandScorer(trg, trg, None, None)
expected_bs_ref_res = ['C.GLY62', 'C.GLN63', 'C.ASP64', 'C.PRO65', 'C.TYR66', 'C.CYS76', 'C.PHE77', 'C.ASN123', 'C.HIS187']
ost.PushVerbosityLevel(ost.LogLevel.Error)
- assert [str(r) for r in sc.rmsd_details["D"][1]["bs_ref_res"]] == expected_bs_ref_res
+ self.assertEqual([str(r) for r in sc.rmsd_details["D"][1]["bs_ref_res"]], expected_bs_ref_res)
ost.PopVerbosityLevel()
def test_unassigned_reasons(self):
@@ -504,24 +504,24 @@ class TestLigandScoring(unittest.TestCase):
# Check unassigned targets
# NA: not in contact with target
trg_na = sc.target.FindResidue("L_NA", 1)
- assert sc.unassigned_target_ligands["L_NA"][1] == "binding_site"
+ self.assertEqual(sc.unassigned_target_ligands["L_NA"][1], "binding_site")
# ZN: no representation
trg_zn = sc.target.FindResidue("H", 1)
- assert sc.unassigned_target_ligands["H"][1] == "model_representation"
+ self.assertEqual(sc.unassigned_target_ligands["H"][1], "model_representation")
# AFB: not identical to anything in the model
trg_afb = sc.target.FindResidue("G", 1)
- assert sc.unassigned_target_ligands["G"][1] == "identity"
+ self.assertEqual(sc.unassigned_target_ligands["G"][1], "identity")
# F.G3D1: J.G3D1 assigned instead
trg_fg3d1 = sc.target.FindResidue("F", 1)
- assert sc.unassigned_target_ligands["F"][1] == "stoichiometry"
+ self.assertEqual(sc.unassigned_target_ligands["F"][1], "stoichiometry")
# CMO: disconnected
trg_cmo1 = sc.target.FindResidue("L_CMO", 1)
- assert sc.unassigned_target_ligands["L_CMO"][1] == "disconnected"
+ self.assertEqual(sc.unassigned_target_ligands["L_CMO"][1], "disconnected")
# J.G3D1: assigned to L_2.G3D1 => error
trg_jg3d1 = sc.target.FindResidue("J", 1)
with self.assertRaises(RuntimeError):
sc._find_unassigned_target_ligand_reason(trg_jg3d1)
- assert "J" not in sc.unassigned_target_ligands
+ self.assertNotIn("J", sc.unassigned_target_ligands)
# Raises with an invalid ligand
with self.assertRaises(ValueError):
sc._find_unassigned_target_ligand_reason(sc.model_ligands[0])
@@ -529,28 +529,28 @@ class TestLigandScoring(unittest.TestCase):
# Check unassigned models
# OXY: not identical to anything in the model
mdl_oxy = sc.model.FindResidue("L_OXY", 1)
- assert sc.unassigned_model_ligands["L_OXY"][1] == "identity"
- assert sc.lddt_pli["L_OXY"][1] is None
+ self.assertEqual(sc.unassigned_model_ligands["L_OXY"][1], "identity")
+ self.assertIsNone(sc.lddt_pli["L_OXY"][1])
# NA: not in contact with target
mdl_na = sc.model.FindResidue("L_NA", 1)
- assert sc.unassigned_model_ligands["L_NA"][1] == "binding_site"
- assert sc.lddt_pli["L_NA"][1] is None
+ self.assertEqual(sc.unassigned_model_ligands["L_NA"][1], "binding_site")
+ self.assertIsNone(sc.lddt_pli["L_NA"][1])
# ZN: no representation
mdl_zn = sc.model.FindResidue("L_ZN", 1)
- assert sc.unassigned_model_ligands["L_ZN"][1] == "model_representation"
- assert sc.lddt_pli["L_ZN"][1] is None
+ self.assertEqual(sc.unassigned_model_ligands["L_ZN"][1], "model_representation")
+ self.assertIsNone(sc.lddt_pli["L_ZN"][1])
# MG in L_MG_2 has stupid coordinates and is not assigned
mdl_mg_2 = sc.model.FindResidue("L_MG_2", 1)
- assert sc.unassigned_model_ligands["L_MG_2"][1] == "stoichiometry"
- assert sc.lddt_pli["L_MG_2"][1] is None
+ self.assertEqual(sc.unassigned_model_ligands["L_MG_2"][1], "stoichiometry")
+ self.assertIsNone(sc.lddt_pli["L_MG_2"][1])
# MG in L_MG_0: assigned to I.MG1 => error
mdl_mg_0 = sc.model.FindResidue("L_MG_0", 1)
with self.assertRaises(RuntimeError):
sc._find_unassigned_model_ligand_reason(mdl_mg_0)
- assert "L_MG_0" not in sc.unassigned_model_ligands
+ self.assertNotIn("L_MG_0", sc.unassigned_model_ligands)
# CMO: disconnected
mdl_cmo1 = sc.model.FindResidue("L_CMO", 1)
- assert sc.unassigned_model_ligands["L_CMO"][1] == "disconnected"
+ self.assertEqual(sc.unassigned_model_ligands["L_CMO"][1], "disconnected")
# Raises with an invalid ligand
with self.assertRaises(ValueError):
sc._find_unassigned_model_ligand_reason(sc.target_ligands[0])
@@ -558,37 +558,37 @@ class TestLigandScoring(unittest.TestCase):
# Should work with rmsd_assignment too
sc = LigandScorer(mdl, trg, None, None, unassigned=True,
rmsd_assignment=True)
- assert sc.unassigned_model_ligands == {
+ self.assertEqual(sc.unassigned_model_ligands, {
'L_ZN': {1: 'model_representation'},
'L_NA': {1: 'binding_site'},
'L_OXY': {1: 'identity'},
'L_MG_2': {1: 'stoichiometry'},
"L_CMO": {1: 'disconnected'}
- }
- assert sc.unassigned_target_ligands == {
+ })
+ self.assertEqual(sc.unassigned_target_ligands, {
'G': {1: 'identity'},
'H': {1: 'model_representation'},
'J': {1: 'stoichiometry'},
'K': {1: 'identity'},
'L_NA': {1: 'binding_site'},
"L_CMO": {1: 'disconnected'}
- }
- assert sc.lddt_pli["L_OXY"][1] is None
+ })
+ self.assertIsNone(sc.lddt_pli["L_OXY"][1])
# With missing ligands
sc = LigandScorer(mdl.Select("cname=A"), trg, None, None)
- assert sc.unassigned_target_ligands["E"][1] == 'no_ligand'
+ self.assertEqual(sc.unassigned_target_ligands["E"][1], 'no_ligand')
sc = LigandScorer(mdl, trg.Select("cname=A"), None, None)
- assert sc.unassigned_model_ligands["L_2"][1] == 'no_ligand'
+ self.assertEqual(sc.unassigned_model_ligands["L_2"][1], 'no_ligand')
sc = LigandScorer(mdl.Select("cname=A"), trg, None, None,
unassigned=True, rmsd_assignment=True)
- assert sc.unassigned_target_ligands["E"][1] == 'no_ligand'
+ self.assertEqual(sc.unassigned_target_ligands["E"][1], 'no_ligand')
sc = LigandScorer(mdl, trg.Select("cname=A"), None, None,
unassigned=True, rmsd_assignment=True)
- assert sc.unassigned_model_ligands["L_2"][1] == 'no_ligand'
+ self.assertEqual(sc.unassigned_model_ligands["L_2"][1], 'no_ligand')
# However not everything must be missing
with self.assertRaises(ValueError):
@@ -614,7 +614,7 @@ class TestLigandScoring(unittest.TestCase):
sc = LigandScorer(mdl.Select("protein=True"), trg.Select("protein=True"),
model_ligands=[mdl_g3d], target_ligands=[trg_g3d1_sub],
substructure_match=True)
- assert sc.rmsd_details["L_2"][1]["coverage"] == 0.75
+ self.assertEqual(sc.rmsd_details["L_2"][1]["coverage"], 0.75)
def test_6jyf(self):
"""6JYF initially caused issues in the CASP15-CAMEO/LIGATE paper where
@@ -629,19 +629,19 @@ class TestLigandScoring(unittest.TestCase):
# Problem is easily fixed by just prioritizing full coverage
sc = LigandScorer(mdl, trg, model_ligands=[mdl_lig],
substructure_match=True)
- assert sc.rmsd_details['00001_'][1]["coverage"] == 1.0
- assert sc.rmsd_details['00001_'][1]["target_ligand"].name == "RET"
+ self.assertEqual(sc.rmsd_details['00001_'][1]["coverage"], 1.0)
+ self.assertEqual(sc.rmsd_details['00001_'][1]["target_ligand"].name, "RET")
self.assertAlmostEqual(sc.rmsd['00001_'][1], 15.56022, 4)
- assert np.array_equal(sc.coverage_matrix,
- np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0.5, 0.3, 0.45, 0, 0, 0.55]]).transpose())
+ self.assertTrue(np.array_equal(sc.coverage_matrix,
+ np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0.5, 0.3, 0.45, 0, 0, 0.55]]).transpose()))
# We need to make sure that it also works if the match is partial.
# For that we load the complete ligand incl. the O missing in target
# with a coverage of around 95% only.
sc = LigandScorer(mdl, trg, model_ligands=[mdl_lig_full],
substructure_match=True)
- assert sc.rmsd_details['00001_'][1]["coverage"] > 0.95
- assert sc.rmsd_details['00001_'][1]["target_ligand"].name == "RET"
+ self.assertTrue(sc.rmsd_details['00001_'][1]["coverage"] > 0.95)
+ self.assertEqual(sc.rmsd_details['00001_'][1]["target_ligand"].name, "RET")
self.assertAlmostEqual(sc.rmsd['00001_'][1], 15.56022, 4)
# Next, we check that coverage_delta has an effect. With a large
@@ -650,8 +650,8 @@ class TestLigandScoring(unittest.TestCase):
sc = LigandScorer(mdl, trg, model_ligands=[mdl_lig_full],
substructure_match=True,
coverage_delta=0.5)
- assert sc.rmsd_details['00001_'][1]["coverage"] > 0.5
- assert sc.rmsd_details['00001_'][1]["target_ligand"].name == "OLA"
+ self.assertTrue(sc.rmsd_details['00001_'][1]["coverage"] > 0.5)
+ self.assertEqual(sc.rmsd_details['00001_'][1]["target_ligand"].name, "OLA")
self.assertAlmostEqual(sc.rmsd['00001_'][1], 6.13006878, 4)
# Finally, we check that we still assign to the full match even with
@@ -659,8 +659,8 @@ class TestLigandScoring(unittest.TestCase):
sc = LigandScorer(mdl, trg, model_ligands=[mdl_lig],
substructure_match=True,
coverage_delta=0.5)
- assert sc.rmsd_details['00001_'][1]["coverage"] == 1.0
- assert sc.rmsd_details['00001_'][1]["target_ligand"].name == "RET"
+ self.assertEqual(sc.rmsd_details['00001_'][1]["coverage"], 1.0)
+ self.assertEqual(sc.rmsd_details['00001_'][1]["target_ligand"].name, "RET")
self.assertAlmostEqual(sc.rmsd['00001_'][1], 15.56022, 4)