from datetime import date import unittest import utils import os import datetime from io import StringIO TOPDIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) utils.set_search_paths(TOPDIR) import modelcif.reader import modelcif.reference import ihm import ihm.reader ASYM_ENTITY = """ loop_ _entity_poly_seq.entity_id _entity_poly_seq.num _entity_poly_seq.mon_id _entity_poly_seq.hetero 1 1 MET . 1 2 CYS . 1 3 MET . 1 4 SER . # loop_ _struct_asym.id _struct_asym.entity_id _struct_asym.details A 1 foo """ class Tests(unittest.TestCase): def test_old_file_read_default(self): """Test default handling of old files""" cif = """ loop_ _audit_conform.dict_name _audit_conform.dict_version mmcif_pdbx.dic 5.311 mmcif_ma.dic 0.14 """ s, = modelcif.reader.read(StringIO(cif)) def test_old_file_read_fail(self): """Test failure reading old files""" cif = """ loop_ _audit_conform.dict_name _audit_conform.dict_version mmcif_pdbx.dic 5.311 mmcif_ma.dic 0.1.3 """ self.assertRaises(modelcif.reader.OldFileError, modelcif.reader.read, StringIO(cif), reject_old_file=True) def test_new_file_read_ok(self): """Test success reading not-old files""" # File read is OK if version is new enough, or version cannot be parsed # because it is non-int or has too many elements for ver in ('1.3.2', '1.3', '0.0.4.3', '0.0a'): cif = """ loop_ _audit_conform.dict_name _audit_conform.dict_version mmcif_pdbx.dic 5.311 mmcif_ma.dic %s """ % ver s, = modelcif.reader.read(StringIO(cif), reject_old_file=True) def test_software_group_handler(self): """Test SoftwareGroupHandler and SoftwareParameterHandler""" cif = """ loop_ _ma_software_parameter.parameter_id _ma_software_parameter.group_id _ma_software_parameter.data_type _ma_software_parameter.name _ma_software_parameter.value _ma_software_parameter.description 1 1 integer foo 42 foodesc 2 1 boolean bar YES . 3 1 string baz ok . 4 1 integer-csv intlist 1,2,3,4 . 5 1 float-csv floatlist 1.5,3.8 . # loop_ _ma_software_group.ordinal_id _ma_software_group.group_id _ma_software_group.software_id _ma_software_group.parameter_group_id 1 1 1 . 2 1 2 . 3 2 3 . 4 2 4 1 """ s, = modelcif.reader.read(StringIO(cif)) s1, s2, s3, s4 = s.software g1, g2 = s.software_groups self.assertEqual(len(g1), 2) self.assertEqual(len(g2), 2) self.assertIsInstance(g1[0], modelcif.Software) self.assertIsInstance(g1[1], modelcif.Software) self.assertEqual(g1[0], s1) self.assertEqual(g1[1], s2) self.assertIsInstance(g2[0], modelcif.Software) self.assertIsInstance(g2[1], modelcif.SoftwareWithParameters) self.assertEqual(g2[0], s3) self.assertEqual(g2[1].software, s4) p1, p2, p3, intlist, floatlist = g2[1].parameters self.assertEqual(p1.name, 'foo') self.assertEqual(p1.value, 42) self.assertEqual(p1.description, 'foodesc') self.assertEqual(p2.name, 'bar') self.assertTrue(p2.value) self.assertIsNone(p2.description) self.assertEqual(p3.name, 'baz') self.assertEqual(p3.value, 'ok') self.assertIsNone(p3.description) self.assertEqual(intlist.value, [1, 2, 3, 4]) f1, f2 = floatlist.value self.assertAlmostEqual(f1, 1.5, delta=1e-1) self.assertAlmostEqual(f2, 3.8, delta=1e-1) def test_enumeration_mapper(self): """Test EnumerationMapper class""" m = modelcif.reader._EnumerationMapper( modelcif.reference, modelcif.reference.TargetReference) # Check get of a handled enumeration value unp = m.get('UNP', None) self.assertIs(unp, modelcif.reference.UniProt) self.assertEqual(unp.name, 'UNP') self.assertIsNone(unp.other_details) # We should get the same class each time (case insensitive) unp2 = m.get('unp', None) self.assertIs(unp, unp2) # Check get of an unhandled value miss = m.get('MIS', None) self.assertEqual(miss.name, 'MIS') self.assertIsNone(unp.other_details) # We should get the same class each time (case insensitive) miss2 = m.get('mis', None) self.assertIs(miss, miss2) # Check get of a custom "other" value custom = m.get('other', "custom type 1") self.assertEqual(custom.name, 'Other') self.assertEqual(custom.other_details, "custom type 1") # We should get the same class each time (case insensitive) custom2 = m.get('Other', "CUSTOM TYPE 1") self.assertIs(custom, custom2) # Check get of a different custom "other" value custom = m.get('other', "custom type 2") self.assertEqual(custom.name, 'Other') self.assertEqual(custom.other_details, "custom type 2") def test_database_handler(self): """Test DatabaseHandler""" cif = """ _database_2.database_id 'PDB' _database_2.database_code '5HVP' """ s, = modelcif.reader.read(StringIO(cif)) self.assertEqual(s.database.id, 'PDB') self.assertEqual(s.database.code, '5HVP') def test_target_ref_db_handler(self): """Test TargetRefDBHander""" cif = """ loop_ _ma_target_ref_db_details.target_entity_id _ma_target_ref_db_details.db_name _ma_target_ref_db_details.db_name_other_details _ma_target_ref_db_details.db_code _ma_target_ref_db_details.db_accession _ma_target_ref_db_details.seq_db_isoform _ma_target_ref_db_details.seq_db_align_begin _ma_target_ref_db_details.seq_db_align_end _ma_target_ref_db_details.ncbi_taxonomy_id _ma_target_ref_db_details.organism_scientific _ma_target_ref_db_details.seq_db_sequence_version_date _ma_target_ref_db_details.seq_db_sequence_checksum _ma_target_ref_db_details.is_primary 1 UNP . MED1_YEAST Q12321 test_iso 1 10 test_tax test_org 1996-11-01 637FEA3E78D915BC YES 1 Other foo . . ? 1 10 . . . . NO 1 other bar . . ? 1 10 . . . . . 1 MIS baz . . ? 1 10 . . . . . """ s, = modelcif.reader.read(StringIO(cif)) e, = s.entities r1, r2, r3, r4 = e.references self.assertIsInstance(r1, modelcif.reference.UniProt) self.assertEqual(r1.code, 'MED1_YEAST') self.assertEqual(r1.accession, 'Q12321') self.assertEqual(r1.isoform, 'test_iso') self.assertEqual(r1.align_begin, 1) self.assertEqual(r1.align_end, 10) self.assertEqual(r1.ncbi_taxonomy_id, 'test_tax') self.assertEqual(r1.organism_scientific, 'test_org') self.assertEqual(r1.sequence_version_date, date(1996, 11, 1)) self.assertIsNone(r1.sequence) self.assertIsNone(r1.details) self.assertTrue(r1.is_primary) self.assertEqual(r1.alignments, []) self.assertEqual(r2.name, 'Other') self.assertFalse(r2.is_primary) self.assertEqual(r2.other_details, 'foo') self.assertEqual(r3.name, 'Other') self.assertEqual(r3.other_details, 'bar') self.assertIsNone(r3.is_primary) self.assertEqual(r4.name, 'MIS') self.assertIsNone(r4.other_details) # should be ignored def test_target_ref_db_handler_with_struct_ref(self): """Test TargetRefDBHander combined with struct_ref info""" cif = """ loop_ _struct_ref.id _struct_ref.entity_id _struct_ref.db_name _struct_ref.db_code _struct_ref.pdbx_db_accession _struct_ref.pdbx_align_begin _struct_ref.pdbx_seq_one_letter_code _struct_ref.details 1 1 UNP MED1_YEAST Q12321 1 DSYVETLDCC "test details" 2 1 UNP sr_only_code sr_only_acc 1 DSYVETLDPP . # # loop_ _struct_ref_seq.align_id _struct_ref_seq.ref_id _struct_ref_seq.seq_align_beg _struct_ref_seq.seq_align_end _struct_ref_seq.db_align_beg _struct_ref_seq.db_align_end 1 1 1 10 1 10 2 2 1 10 1 10 # loop_ _ma_target_ref_db_details.target_entity_id _ma_target_ref_db_details.db_name _ma_target_ref_db_details.db_name_other_details _ma_target_ref_db_details.db_code _ma_target_ref_db_details.db_accession _ma_target_ref_db_details.seq_db_isoform _ma_target_ref_db_details.seq_db_align_begin _ma_target_ref_db_details.seq_db_align_end _ma_target_ref_db_details.ncbi_taxonomy_id _ma_target_ref_db_details.organism_scientific _ma_target_ref_db_details.seq_db_sequence_version_date _ma_target_ref_db_details.seq_db_sequence_checksum _ma_target_ref_db_details.is_primary 1 UNP . MED1_YEAST Q12321 test_iso 1 10 test_tax test_org 1996-11-01 637FEA3E78D915BC YES 1 UNP . rd_only_code rd_only_acc rd_only_iso . . . . . . NO """ s, = modelcif.reader.read(StringIO(cif)) e, = s.entities r1, r2, r3 = e.references # r1 should contain both target_ref_db and struct_ref info self.assertIsInstance(r1, modelcif.reference.UniProt) self.assertEqual(r1.code, 'MED1_YEAST') self.assertEqual(r1.accession, 'Q12321') self.assertEqual(r1.isoform, 'test_iso') self.assertEqual(r1.align_begin, 1) self.assertEqual(r1.align_end, 10) self.assertEqual(r1.ncbi_taxonomy_id, 'test_tax') self.assertEqual(r1.organism_scientific, 'test_org') self.assertEqual(r1.sequence_version_date, date(1996, 11, 1)) self.assertEqual(r1.sequence, 'DSYVETLDCC') self.assertEqual(r1.details, "test details") self.assertTrue(r1.is_primary) a, = r1.alignments self.assertEqual(a.db_begin, 1) self.assertEqual(a.db_end, 10) self.assertEqual(a.entity_begin, 1) self.assertEqual(a.entity_end, 10) # r2 should contain only target_ref_db info self.assertIsInstance(r2, modelcif.reference.UniProt) self.assertEqual(r2.code, 'rd_only_code') self.assertEqual(r2.accession, 'rd_only_acc') self.assertEqual(r2.isoform, 'rd_only_iso') self.assertIsNone(r2.sequence) self.assertFalse(r2.is_primary) # r3 should contain only struct_ref info self.assertIsInstance(r3, modelcif.reference.UniProt) self.assertEqual(r3.code, 'sr_only_code') self.assertEqual(r3.accession, 'sr_only_acc') self.assertIsNone(r3.isoform) self.assertIsNone(r3.ncbi_taxonomy_id) self.assertEqual(r3.sequence, 'DSYVETLDPP') self.assertIsNone(r3.is_primary) a, = r3.alignments self.assertEqual(a.db_begin, 1) self.assertEqual(a.db_end, 10) self.assertEqual(a.entity_begin, 1) self.assertEqual(a.entity_end, 10) def test_transformation_handler(self): """Test _TransformationHandler""" cif = """ loop_ _ma_template_trans_matrix.id _ma_template_trans_matrix.rot_matrix[1][1] _ma_template_trans_matrix.rot_matrix[2][1] _ma_template_trans_matrix.rot_matrix[3][1] _ma_template_trans_matrix.rot_matrix[1][2] _ma_template_trans_matrix.rot_matrix[2][2] _ma_template_trans_matrix.rot_matrix[3][2] _ma_template_trans_matrix.rot_matrix[1][3] _ma_template_trans_matrix.rot_matrix[2][3] _ma_template_trans_matrix.rot_matrix[3][3] _ma_template_trans_matrix.tr_vector[1] _ma_template_trans_matrix.tr_vector[2] _ma_template_trans_matrix.tr_vector[3] 1 1.000000 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 1.000000 0.000 0.000 0.000 """ s, = modelcif.reader.read(StringIO(cif)) t, = s.template_transformations self.assertAlmostEqual(t.rot_matrix[0][0], 1.0, delta=1e-6) self.assertAlmostEqual(t.tr_vector[0], 0.0, delta=1e-6) def test_template_details_handler(self): """Test _TemplateDetailsHandler""" cif = """ loop_ _ma_template_details.ordinal_id _ma_template_details.template_id _ma_template_details.template_origin _ma_template_details.template_entity_type _ma_template_details.template_trans_matrix_id _ma_template_details.template_data_id _ma_template_details.target_asym_id _ma_template_details.template_label_asym_id _ma_template_details.template_label_entity_id _ma_template_details.template_model_num _ma_template_details.template_auth_asym_id 1 1 'reference database' polymer 1 2 A B 3 4 Z 2 2 'reference database' polymer 2 3 . B 3 4 Z 3 3 customized polymer 2 3 . B 3 4 Z """ s, = modelcif.reader.read(StringIO(cif)) t, t2, t3 = s.templates self.assertIsInstance(t, modelcif.Template) self.assertIsInstance(t2, modelcif.Template) self.assertIsInstance(t3, modelcif.CustomTemplate) self.assertEqual(t.entity_id, '3') self.assertEqual(t.model_num, 4) self.assertEqual(t.asym_id, 'B') self.assertEqual(t.strand_id, 'Z') self.assertEqual(len(s.alignments), 0) def test_template_customized_handler(self): """Test _TemplateCustomizedHandler""" cif = """ loop_ _ma_template_details.ordinal_id _ma_template_details.template_id 1 1 # loop_ _ma_template_customized.template_id _ma_template_customized.details 1 'details x' 2 'details y' """ s, = modelcif.reader.read(StringIO(cif)) t1, t2 = s.templates # template_details does not specify template_origin, so template #1 # will be initially instantiated as a Template, and should be corrected # to CustomTemplate on reading template_customized: self.assertIsInstance(t1, modelcif.CustomTemplate) self.assertEqual(t1.details, 'details x') self.assertEqual(len(t1.atoms), 0) self.assertIsInstance(t2, modelcif.CustomTemplate) self.assertEqual(t2.details, 'details y') self.assertEqual(len(t2.atoms), 0) def test_template_details_handler_nonpoly(self): """Test _TemplateDetailsHandler with nonpolymeric template""" cif = """ loop_ _pdbx_entity_nonpoly.entity_id _pdbx_entity_nonpoly.name _pdbx_entity_nonpoly.comp_id _pdbx_entity_nonpoly.ma_model_mode 3 Heme HEM explicit # loop_ _ma_template_details.ordinal_id _ma_template_details.template_id _ma_template_details.template_origin _ma_template_details.template_entity_type _ma_template_details.template_trans_matrix_id _ma_template_details.template_data_id _ma_template_details.target_asym_id _ma_template_details.template_label_asym_id _ma_template_details.template_label_entity_id _ma_template_details.template_model_num _ma_template_details.template_auth_asym_id 1 1 'reference database' non-polymer 1 2 A B 3 4 Z # loop_ _ma_template_non_poly.template_id _ma_template_non_poly.comp_id _ma_template_non_poly.details 1 HEM "Template Heme" """ s, = modelcif.reader.read(StringIO(cif)) t, = s.templates self.assertEqual(t.entity_id, '3') self.assertEqual(t.model_num, 4) self.assertEqual(t.asym_id, 'B') self.assertEqual(t.strand_id, 'Z') self.assertEqual(len(s.alignments), 0) self.assertEqual(t.entity.description, 'Template Heme') a, = s.asym_units self.assertIsInstance(a, modelcif.NonPolymerFromTemplate) self.assertIs(a.template, t) self.assertTrue(a.explicit) def test_custom_template_coord_handler(self): """Test reading of coordinates for CustomTemplate""" cif = """ loop_ _ma_template_details.ordinal_id _ma_template_details.template_id _ma_template_details.template_origin _ma_template_details.template_entity_type _ma_template_details.template_trans_matrix_id _ma_template_details.template_data_id _ma_template_details.target_asym_id _ma_template_details.template_label_asym_id _ma_template_details.template_label_entity_id _ma_template_details.template_model_num _ma_template_details.template_auth_asym_id 1 1 customized polymer 2 3 . B 3 4 Z # loop_ _ma_template_customized.template_id _ma_template_customized.details 1 'Provided by user' # loop_ _ma_template_coord.template_id _ma_template_coord.group_PDB _ma_template_coord.ordinal_id _ma_template_coord.type_symbol _ma_template_coord.label_atom_id _ma_template_coord.label_comp_id _ma_template_coord.label_seq_id _ma_template_coord.label_asym_id _ma_template_coord.auth_seq_id _ma_template_coord.auth_asym_id _ma_template_coord.auth_atom_id _ma_template_coord.auth_comp_id _ma_template_coord.Cartn_x _ma_template_coord.Cartn_y _ma_template_coord.Cartn_z _ma_template_coord.occupancy _ma_template_coord.label_entity_id _ma_template_coord.B_iso_or_equiv _ma_template_coord.formal_charge 1 ATOM 1 C CA ALA 1 A 42 A X XXX 0 1.000 2.000 0.500 9 2.000 1.000 1 ATOM 2 O OXT CYS 2 A . A . . 1.000 2.000 3.000 . 9 . . # """ s, = modelcif.reader.read(StringIO(cif)) t, = s.templates self.assertIsInstance(t, modelcif.CustomTemplate) self.assertEqual(t.details, 'Provided by user') self.assertEqual(len(t.atoms), 2) a1 = t.atoms[0] self.assertEqual(a1.seq_id, 1) self.assertEqual(a1.atom_id, 'CA') self.assertEqual(a1.type_symbol, 'C') self.assertAlmostEqual(a1.x, 0.0, delta=1e-2) self.assertAlmostEqual(a1.y, 1.0, delta=1e-2) self.assertAlmostEqual(a1.z, 2.0, delta=1e-2) self.assertAlmostEqual(a1.occupancy, 0.5, delta=1e-2) self.assertAlmostEqual(a1.biso, 2.0, delta=1e-2) self.assertAlmostEqual(a1.charge, 1.0, delta=1e-2) self.assertEqual(a1.auth_seq_id, 42) self.assertEqual(a1.auth_comp_id, 'XXX') self.assertEqual(a1.auth_atom_id, 'X') a2 = t.atoms[1] self.assertEqual(a2.seq_id, 2) self.assertEqual(a2.atom_id, 'OXT') self.assertEqual(a2.type_symbol, 'O') def test_entity_nonpoly_bad_model_mode(self): """Test pdbx_entity_nonpoly with missing ma_model_mode""" cif = """ loop_ _struct_asym.id _struct_asym.entity_id A 1 B 2 C 3 # loop_ _pdbx_entity_nonpoly.entity_id _pdbx_entity_nonpoly.name _pdbx_entity_nonpoly.comp_id _pdbx_entity_nonpoly.ma_model_mode 1 test1 TE1 explicit 2 test2 TE2 . 3 test3 TE3 ? # loop_ _ma_template_details.ordinal_id _ma_template_details.template_id _ma_template_details.template_origin _ma_template_details.template_entity_type _ma_template_details.template_trans_matrix_id _ma_template_details.template_data_id _ma_template_details.target_asym_id _ma_template_details.template_label_asym_id _ma_template_details.template_label_entity_id _ma_template_details.template_model_num _ma_template_details.template_auth_asym_id 1 1 'reference database' non-polymer 1 2 A A 1 4 Z 2 2 'reference database' non-polymer 1 3 B B 2 4 Z 3 3 'reference database' non-polymer 1 4 C C 3 4 Z # loop_ _ma_template_non_poly.template_id _ma_template_non_poly.comp_id _ma_template_non_poly.details 1 TE1 test1 2 TE2 test2 3 TE3 test3 """ s, = modelcif.reader.read(StringIO(cif)) a1, a2, a3 = s.asym_units self.assertTrue(a1.explicit) self.assertIsNone(a2.explicit) self.assertIs(a3.explicit, ihm.unknown) def test_template_ref_db_handler(self): """Test _TemplateRefDBHandler""" cif = """ loop_ _ma_template_ref_db_details.template_id _ma_template_ref_db_details.db_name _ma_template_ref_db_details.db_name_other_details _ma_template_ref_db_details.db_accession_code _ma_template_ref_db_details.db_version_date 1 PDB . 3nc1 2021-10-06 1 MIS . testacc . 1 Other foo acc2 . 1 PubChem . 1046 . 1 AlphaFoldDB . I6XD65 2022-06-01 """ s, = modelcif.reader.read(StringIO(cif)) t, = s.templates r1, r2, r3, r4, r5 = t.references self.assertIsInstance(r1, modelcif.reference.PDB) self.assertEqual(r1.accession, '3nc1') self.assertEqual(r1.db_version_date, date(2021, 10, 6)) self.assertEqual(r2.name, 'MIS') self.assertIsNone(r2.other_details) self.assertIsNone(r2.db_version_date) self.assertEqual(r3.name, 'Other') self.assertEqual(r3.other_details, 'foo') self.assertIsInstance(r4, modelcif.reference.PubChem) self.assertEqual(r4.accession, '1046') self.assertIsInstance(r5, modelcif.reference.AlphaFoldDB) self.assertEqual(r5.accession, 'I6XD65') self.assertEqual(r5.db_version_date, date(2022, 6, 1)) def _get_models_cif(self, old=False): if old: cif = """ loop_ _ma_model_list.ordinal_id _ma_model_list.model_id _ma_model_list.model_group_id _ma_model_list.model_name _ma_model_list.model_group_name _ma_model_list.assembly_id _ma_model_list.data_id _ma_model_list.model_type _ma_model_list.model_type_other_details 1 1 1 'Best scoring model' 'All models' 99 4 'Homology model' . 2 2 1 '2nd best scoring model' 'All models' 99 5 'Ab initio model' . 3 3 2 'Best scoring model' 'group2' 99 6 'Other' 'Custom other model' # """ else: cif = """ loop_ _ma_model_list.ordinal_id _ma_model_list.model_name _ma_model_list.assembly_id _ma_model_list.data_id _ma_model_list.model_type _ma_model_list.model_type_other_details 1 'Best scoring model' 99 4 'Homology model' . 2 '2nd best scoring model' 99 5 'Ab initio model' . 3 'Best scoring model' 99 6 'Other' 'Custom other model' # loop_ _ma_model_group.id _ma_model_group.name _ma_model_group.details 1 'All models' . 2 'group2' 'second group details' # # loop_ _ma_model_group_link.group_id _ma_model_group_link.model_id 1 1 1 2 2 3 # """ cif += """ loop_ _atom_site.group_PDB _atom_site.id _atom_site.type_symbol _atom_site.label_atom_id _atom_site.label_alt_id _atom_site.label_comp_id _atom_site.label_seq_id _atom_site.auth_seq_id _atom_site.pdbx_PDB_ins_code _atom_site.label_asym_id _atom_site.Cartn_x _atom_site.Cartn_y _atom_site.Cartn_z _atom_site.occupancy _atom_site.label_entity_id _atom_site.auth_asym_id _atom_site.B_iso_or_equiv _atom_site.pdbx_PDB_model_num ATOM 1 C CA . ASP 1 1 ? A 1.000 2.000 3.000 . 1 A . 6 ATOM 2 C CA . ASP 1 1 ? A 1.000 2.000 3.000 . 1 A . 8 """ return cif def test_model_list_handler_default_old(self): """Test _ModelListHandler with default model class, old dictionary""" self._test_model_list_handler_default(old=True) def test_model_list_handler_default(self): """Test _ModelListHandler with default model class""" self._test_model_list_handler_default(old=False) def _test_model_list_handler_default(self, old): cif = self._get_models_cif(old=old) s, = modelcif.reader.read(StringIO(cif)) mg1, mg2, mg3 = s.model_groups self.assertEqual(mg1.name, 'All models') m1, m2 = list(mg1) self.assertIsInstance(m1, modelcif.model.HomologyModel) self.assertEqual(m1.model_type, 'Homology model') self.assertIsNone(m1.other_details) self.assertIsInstance(m2, modelcif.model.AbInitioModel) self.assertEqual(m2.model_type, 'Ab initio model') self.assertIsNone(m2.other_details) self.assertEqual(m1.name, 'Best scoring model') self.assertEqual(m2.name, '2nd best scoring model') self.assertEqual(mg2.name, 'group2') m1, = list(mg2) self.assertEqual(m1.model_type, 'Other') self.assertEqual(m1.other_details, 'Custom other model') self.assertEqual(m1.name, 'Best scoring model') self.assertEqual(m1.assembly._id, '99') # Last group is auto-created to contain the non-grouped models # referenced by atom_site self.assertIsNone(mg3.name) m1, m2 = list(mg3) self.assertEqual(m1.model_type, 'Other') self.assertEqual(m1._id, '6') self.assertEqual(m2.model_type, 'Other') self.assertEqual(m2._id, '8') def test_model_list_handler_group_new_old(self): """Test _ModelListHandler handling mix of new and old style groups""" cif = """ loop_ _ma_model_list.ordinal_id _ma_model_list.model_id _ma_model_list.model_group_id _ma_model_list.model_name _ma_model_list.model_group_name _ma_model_list.data_id _ma_model_list.model_type _ma_model_list.model_type_other_details 1 1 1 . . 4 'Homology model' . 2 2 . . . 4 'Homology model' . 3 3 1 . . 4 'Homology model' . # # loop_ _ma_model_group.id _ma_model_group.name _ma_model_group.details 1 'group1' . 2 'group2' . # # loop_ _ma_model_group_link.model_id _ma_model_group_link.group_id 2 1 3 2 """ s, = modelcif.reader.read(StringIO(cif)) # model1 is in group1, using old-style tables; # model2 is in group1, using new-style tables; # model3 is in group2 according to new-style tables but group1 # according to old style (new-style should take precedence) mg1, mg2 = s.model_groups self.assertEqual(mg1._id, '1') self.assertEqual(mg2._id, '2') self.assertEqual([m._id for m in mg1], ['2', '1']) self.assertEqual([m._id for m in mg2], ['3']) def test_model_list_handler_custom(self): """Test _ModelListHandler with custom model class""" class MyModel(modelcif.model.Model): """Custom model type""" pass cif = self._get_models_cif() s, = modelcif.reader.read(StringIO(cif), model_class=MyModel) mg1, mg2, mg3 = s.model_groups m1, m2 = list(mg1) m3, = list(mg2) m4, m5 = list(mg3) # Custom model type should always be returned, regardless of what # the mmCIF file says it is, but model_type should be set self.assertIsInstance(m1, MyModel) self.assertIsInstance(m2, MyModel) self.assertIsInstance(m3, MyModel) self.assertIsInstance(m4, MyModel) self.assertIsInstance(m5, MyModel) self.assertEqual(m1.model_type, 'Homology model') self.assertEqual(m2.model_type, 'Ab initio model') self.assertEqual(m3.model_type, 'Other') self.assertEqual(m4.model_type, 'Other') self.assertEqual(m5.model_type, 'Other') def test_assembly_handler(self): """Test _AssemblyHandler and _AssemblyDetailsHandler""" cif = """ loop_ _entity_poly_seq.entity_id _entity_poly_seq.num _entity_poly_seq.mon_id 1 1 ALA 1 2 ALA # loop_ _struct_asym.id _struct_asym.entity_id _struct_asym.details A 1 Nup84 # loop_ _ma_struct_assembly.ordinal_id _ma_struct_assembly.assembly_id _ma_struct_assembly.entity_id _ma_struct_assembly.asym_id _ma_struct_assembly.seq_id_begin _ma_struct_assembly.seq_id_end 1 1 1 A 1 2 2 1 1 A 1 1 3 1 1 A . . # loop_ _ma_struct_assembly_details.assembly_id _ma_struct_assembly_details.assembly_name _ma_struct_assembly_details.assembly_description 1 foo bar """ s, = modelcif.reader.read(StringIO(cif)) a, = s.assemblies self.assertEqual(a.name, 'foo') self.assertEqual(a.description, 'bar') self.assertEqual(len(a), 3) # Complete asym self.assertIsInstance(a[0], modelcif.AsymUnit) # asym range self.assertIsInstance(a[1], modelcif.AsymUnitRange) self.assertEqual(a[1].seq_id_range, (1, 1)) # No specified range -> complete asym self.assertIsInstance(a[2], modelcif.AsymUnit) def test_template_poly_segment_handler(self): """Test _TemplatePolySegmentHandler""" cif = """ loop_ _ma_template_poly_segment.id _ma_template_poly_segment.template_id _ma_template_poly_segment.residue_number_begin _ma_template_poly_segment.residue_number_end 1 42 2 9 """ s, = modelcif.reader.read(StringIO(cif)) seg, = s.template_segments self.assertEqual(seg.template._id, '42') self.assertEqual(seg.seq_id_range, (2, 9)) def test_data__handler(self): """Test _DataHandler""" cif = """ loop_ _ma_data.id _ma_data.name _ma_data.content_type _ma_data.content_type_other_details 1 'Template Structure' 'template structure' . 2 'Model subunit' target . 3 'Default model name' 'model coordinates' . # loop_ _ma_template_details.ordinal_id _ma_template_details.template_id _ma_template_details.template_origin _ma_template_details.template_entity_type _ma_template_details.template_trans_matrix_id _ma_template_details.template_data_id _ma_template_details.target_asym_id _ma_template_details.template_label_asym_id _ma_template_details.template_label_entity_id _ma_template_details.template_model_num _ma_template_details.template_auth_asym_id 1 1 'reference database' polymer 1 1 A A 1 1 Z # loop_ _ma_model_list.ordinal_id _ma_model_list.model_id _ma_model_list.model_group_id _ma_model_list.model_name _ma_model_list.model_group_name _ma_model_list.assembly_id _ma_model_list.data_id _ma_model_list.model_type _ma_model_list.model_type_other_details 1 1 1 'Model name' 'All models' 1 3 'Homology model' . """ s, = modelcif.reader.read(StringIO(cif)) d1, d2, d3 = s.data self.assertIsInstance(d1, modelcif.Template) # d2 is not referenced by any other table, so gets Data base class self.assertIsInstance(d2, modelcif.data.Data) self.assertIsInstance(d3, modelcif.model.Model) # Name not given in template_details so taken from ma_data self.assertEqual(d1.name, 'Template Structure') self.assertEqual(d2.name, 'Model subunit') # Name in model_list used rather than that from ma_data self.assertEqual(d3.name, 'Model name') def test_data_group_handler(self): """Test _DataGroupHandler""" cif = """ loop_ _ma_data.id _ma_data.name _ma_data.content_type _ma_data.content_type_other_details 1 'Template Structure' 'template structure' . 2 'Model subunit' target . # loop_ _ma_template_details.ordinal_id _ma_template_details.template_id _ma_template_details.template_origin _ma_template_details.template_entity_type _ma_template_details.template_trans_matrix_id _ma_template_details.template_data_id _ma_template_details.target_asym_id _ma_template_details.template_label_asym_id _ma_template_details.template_label_entity_id _ma_template_details.template_model_num _ma_template_details.template_auth_asym_id 1 1 'reference database' polymer 1 1 A A 1 1 Z # loop_ _ma_data_group.ordinal_id _ma_data_group.group_id _ma_data_group.data_id 1 1 1 2 1 2 3 2 3 """ s, = modelcif.reader.read(StringIO(cif)) g1, g2, = s.data_groups self.assertEqual(len(g1), 2) self.assertIsInstance(g1[0], modelcif.Template) self.assertEqual(g1[0]._data_id, '1') self.assertIsInstance(g1[1], modelcif.data.Data) self.assertEqual(g1[1]._data_id, '2') self.assertEqual(len(g2), 1) self.assertIsNone(g2[0]) def test_data_ref_db_handler(self): """Test _DataRefDBHandler""" cif = """ loop_ _ma_data.id _ma_data.name _ma_data.content_type _ma_data.content_type_other_details 1 defaultname1 'reference database' . 2 defaultname2 'reference database' . # loop_ _ma_data_ref_db.data_id _ma_data_ref_db.name _ma_data_ref_db.location_url _ma_data_ref_db.version _ma_data_ref_db.release_date 1 name1 url1 1.0 1979-11-22 2 . url2 . . """ s, = modelcif.reader.read(StringIO(cif)) d1, d2 = s.data self.assertIsInstance(d1, modelcif.ReferenceDatabase) self.assertIsInstance(d2, modelcif.ReferenceDatabase) # Name in ma_data_ref_db used rather than that from ma_data self.assertEqual(d1.name, 'name1') self.assertEqual(d1.url, 'url1') self.assertEqual(d1.version, '1.0') self.assertIsInstance(d1.release_date, date) self.assertEqual(d1.release_date, date(1979, 11, 22)) # Name not given in ma_data_ref_db so taken from ma_data self.assertEqual(d2.name, 'defaultname2') self.assertIsNone(d2.version) self.assertIsNone(d2.release_date) def test_protocol_handler(self): """Test _ProtocolHandler""" cif = """ loop_ _ma_protocol_step.ordinal_id _ma_protocol_step.protocol_id _ma_protocol_step.step_id _ma_protocol_step.method_type _ma_protocol_step.step_name _ma_protocol_step.details _ma_protocol_step.software_group_id _ma_protocol_step.input_data_group_id _ma_protocol_step.output_data_group_id 1 1 1 'template search' 'ModPipe Seq-Prf (0001)' . 1 1 2 2 1 2 'template selection' . . . . . 3 1 3 'target-template alignment' . . . . . 4 1 4 modeling . . 2 2 1 5 1 5 'model selection' . . 1 1 1 6 1 6 'model refinement' . . . . . 7 1 7 other testname testdetails 42 99 66 """ s, = modelcif.reader.read(StringIO(cif)) p, = s.protocols self.assertEqual(len(p.steps), 7) s1, s2, s3, s4, s5, s6, s7 = p.steps self.assertIsInstance(s1, modelcif.protocol.TemplateSearchStep) self.assertIsInstance(s2, modelcif.protocol.TemplateSelectionStep) self.assertIsInstance(s3, modelcif.protocol.TargetTemplateAlignmentStep) self.assertIsInstance(s4, modelcif.protocol.ModelingStep) self.assertIsInstance(s5, modelcif.protocol.ModelSelectionStep) self.assertIsInstance(s6, modelcif.protocol.ModelRefinementStep) self.assertIsInstance(s7, modelcif.protocol.Step) self.assertEqual(s7.method_type, "other") self.assertEqual(s7.name, "testname") self.assertEqual(s7.details, "testdetails") self.assertEqual(s7.input_data._id, '99') self.assertEqual(s7.output_data._id, '66') self.assertEqual(s7.software._id, '42') def test_target_entity_handler(self): """Test _TargetEntityHandler""" cif = """ loop_ _ma_target_entity.entity_id _ma_target_entity.data_id _ma_target_entity.origin 1 2 'reference database' """ s, = modelcif.reader.read(StringIO(cif)) e, = s.entities self.assertEqual(e._data_id, '2') def test_qa_metric_global_handler(self): """Test _QAMetricGlobalHandler""" cif = """ loop_ _ma_model_list.ordinal_id _ma_model_list.model_id _ma_model_list.model_group_id _ma_model_list.model_name _ma_model_list.model_group_name _ma_model_list.assembly_id _ma_model_list.data_id _ma_model_list.model_type _ma_model_list.model_type_other_details 1 1 1 'Best scoring model' 'All models' 1 4 'Homology model' . # loop_ _ma_qa_metric.id _ma_qa_metric.name _ma_qa_metric.description _ma_qa_metric.type _ma_qa_metric.mode _ma_qa_metric.type_other_details _ma_qa_metric.software_group_id 1 MPQS 'ModPipe Quality Score' other global 'composite score, values >1.1 are considered reliable' 1 2 zDOPE 'Normalized DOPE' zscore global . 2 3 'TSVMod RMSD' 'TSVMod predicted RMSD (MSALL)' distance global . . 4 'TSVMod NO35' . 'normalized score' global . . # loop_ _ma_qa_metric_global.ordinal_id _ma_qa_metric_global.model_id _ma_qa_metric_global.metric_id _ma_qa_metric_global.metric_value 1 1 1 1.0 2 1 2 2.0 3 1 3 3.0 4 1 4 4.0 """ s, = modelcif.reader.read(StringIO(cif)) mg, = s.model_groups m, = mg q1, q2, q3, q4 = m.qa_metrics self.assertIsInstance(q1, modelcif.qa_metric.Global) self.assertEqual(q1.type, "other") self.assertEqual(q1.name, "MPQS") self.assertEqual(type(q1).__name__, "MPQS") self.assertEqual(q1.description, "ModPipe Quality Score") self.assertEqual(q1.__doc__, "ModPipe Quality Score") self.assertEqual(q1.software._id, '1') self.assertAlmostEqual(q1.value, 1.0, delta=1e-6) self.assertIsInstance(q2, modelcif.qa_metric.Global) self.assertIsInstance(q2, modelcif.qa_metric.ZScore) self.assertAlmostEqual(q2.value, 2.0, delta=1e-6) self.assertIsInstance(q3, modelcif.qa_metric.Global) self.assertIsInstance(q3, modelcif.qa_metric.Distance) self.assertAlmostEqual(q3.value, 3.0, delta=1e-6) self.assertIsInstance(q4, modelcif.qa_metric.Global) self.assertIsInstance(q4, modelcif.qa_metric.NormalizedScore) self.assertIsNone(q4.description) self.assertIsNone(q4.__doc__) def test_qa_metric_local_handler(self): """Test _QAMetricLocalHandler""" cif = """ loop_ _ma_model_list.ordinal_id _ma_model_list.model_id _ma_model_list.model_group_id _ma_model_list.model_name _ma_model_list.model_group_name _ma_model_list.assembly_id _ma_model_list.data_id _ma_model_list.model_type _ma_model_list.model_type_other_details 1 1 1 'Best scoring model' 'All models' 1 4 'Homology model' . # loop_ _ma_qa_metric.id _ma_qa_metric.name _ma_qa_metric.description _ma_qa_metric.type _ma_qa_metric.mode _ma_qa_metric.type_other_details _ma_qa_metric.software_group_id 1 'test local' 'some local score' 'normalized score' local . . # loop_ _ma_qa_metric_local.ordinal_id _ma_qa_metric_local.model_id _ma_qa_metric_local.label_asym_id _ma_qa_metric_local.label_seq_id _ma_qa_metric_local.label_comp_id _ma_qa_metric_local.metric_id _ma_qa_metric_local.metric_value 1 1 A 2 CYS 1 1.0 """ s, = modelcif.reader.read(StringIO(cif)) mg, = s.model_groups m, = mg q1, = m.qa_metrics self.assertIsInstance(q1, modelcif.qa_metric.Local) self.assertIsInstance(q1, modelcif.qa_metric.NormalizedScore) self.assertEqual(q1.type, "normalized score") self.assertEqual(q1.name, "test local") self.assertEqual(q1.description, "some local score") self.assertIsNone(q1.software) self.assertEqual(q1.residue.asym._id, 'A') self.assertEqual(q1.residue.seq_id, 2) self.assertAlmostEqual(q1.value, 1.0, delta=1e-6) def test_qa_metric_pairwise_handler(self): """Test _QAMetricPairwiseHandler""" cif = """ loop_ _ma_model_list.ordinal_id _ma_model_list.model_id _ma_model_list.model_group_id _ma_model_list.model_name _ma_model_list.model_group_name _ma_model_list.assembly_id _ma_model_list.data_id _ma_model_list.model_type _ma_model_list.model_type_other_details 1 1 1 'Best scoring model' 'All models' 1 4 'Homology model' . # loop_ _ma_qa_metric.id _ma_qa_metric.name _ma_qa_metric.description _ma_qa_metric.type _ma_qa_metric.mode _ma_qa_metric.type_other_details _ma_qa_metric.software_group_id 1 'test pair' 'some pair score' 'normalized score' local-pairwise . . # loop_ _ma_qa_metric_local_pairwise.ordinal_id _ma_qa_metric_local_pairwise.model_id _ma_qa_metric_local_pairwise.label_asym_id_1 _ma_qa_metric_local_pairwise.label_seq_id_1 _ma_qa_metric_local_pairwise.label_comp_id_1 _ma_qa_metric_local_pairwise.label_asym_id_2 _ma_qa_metric_local_pairwise.label_seq_id_2 _ma_qa_metric_local_pairwise.label_comp_id_2 _ma_qa_metric_local_pairwise.metric_id _ma_qa_metric_local_pairwise.metric_value 1 1 A 2 CYS B 4 GLY 1 1.0 """ s, = modelcif.reader.read(StringIO(cif)) mg, = s.model_groups m, = mg q1, = m.qa_metrics self.assertIsInstance(q1, modelcif.qa_metric.LocalPairwise) self.assertIsInstance(q1, modelcif.qa_metric.NormalizedScore) self.assertEqual(q1.type, "normalized score") self.assertEqual(q1.name, "test pair") self.assertEqual(q1.description, "some pair score") self.assertIsNone(q1.software) self.assertEqual(q1.residue1.asym._id, 'A') self.assertEqual(q1.residue1.seq_id, 2) self.assertEqual(q1.residue2.asym._id, 'B') self.assertEqual(q1.residue2.seq_id, 4) self.assertAlmostEqual(q1.value, 1.0, delta=1e-6) def test_qa_metric_feature_handler(self): """Test _QAMetricFeatureHandler""" feat = """ loop_ _ma_atom_feature.ordinal_id _ma_atom_feature.feature_id _ma_atom_feature.atom_id 1 1 1 # loop_ _ma_poly_residue_feature.ordinal_id _ma_poly_residue_feature.feature_id _ma_poly_residue_feature.label_asym_id _ma_poly_residue_feature.label_seq_id _ma_poly_residue_feature.label_comp_id 1 2 Y 1 ALA # loop_ _ma_entity_instance_feature.ordinal_id _ma_entity_instance_feature.feature_id _ma_entity_instance_feature.label_asym_id 1 3 Y """ qa = """ loop_ _ma_feature_list.feature_id _ma_feature_list.feature_type _ma_feature_list.entity_type _ma_feature_list.details 1 atom other 'atom f' 2 residue polymer prf 3 'entity instance' polymer . # loop_ _ma_model_list.ordinal_id _ma_model_list.model_id _ma_model_list.model_group_id _ma_model_list.model_name _ma_model_list.model_group_name _ma_model_list.assembly_id _ma_model_list.data_id _ma_model_list.model_type _ma_model_list.model_type_other_details 1 1 1 'Best scoring model' 'All models' 1 4 'Homology model' . # loop_ _ma_qa_metric.id _ma_qa_metric.name _ma_qa_metric.description _ma_qa_metric.type _ma_qa_metric.mode _ma_qa_metric.type_other_details _ma_qa_metric.software_group_id 1 'test local' 'some local score' 'normalized score' per-feature . . # loop_ _ma_qa_metric_feature.ordinal_id _ma_qa_metric_feature.model_id _ma_qa_metric_feature.feature_id _ma_qa_metric_feature.metric_id _ma_qa_metric_feature.metric_value 1 1 1 1 1.0 2 1 2 1 2.0 3 1 3 1 3.0 """ # Test both ways to make sure features still work if they are # referenced by ID before their type is known for cif in (feat + qa, qa + feat): s, = modelcif.reader.read(StringIO(cif)) mg, = s.model_groups m, = mg q1, q2, q3 = m.qa_metrics self.assertIsInstance(q1, modelcif.qa_metric.Feature) self.assertIsInstance(q1, modelcif.qa_metric.NormalizedScore) self.assertIsInstance(q1.feature, modelcif.AtomFeature) self.assertEqual(q1.feature.details, 'atom f') self.assertAlmostEqual(q1.value, 1.0, delta=1e-6) self.assertIsInstance(q2.feature, modelcif.PolyResidueFeature) self.assertEqual(len(q2.feature.residues), 1) self.assertEqual(q2.feature.residues[0].seq_id, 1) self.assertAlmostEqual(q2.value, 2.0, delta=1e-6) self.assertIsInstance(q3.feature, modelcif.EntityInstanceFeature) self.assertEqual(len(q3.feature.asym_units), 1) self.assertAlmostEqual(q3.value, 3.0, delta=1e-6) def test_qa_metric_feature_pairwise_handler(self): """Test _QAMetricFeaturePairwiseHandler""" feat = """ loop_ _ma_poly_residue_feature.ordinal_id _ma_poly_residue_feature.feature_id _ma_poly_residue_feature.label_asym_id _ma_poly_residue_feature.label_seq_id _ma_poly_residue_feature.label_comp_id 1 1 Y 1 ALA 2 2 Y 2 CYS """ qa = """ loop_ _ma_feature_list.feature_id _ma_feature_list.feature_type _ma_feature_list.entity_type _ma_feature_list.details 1 residue polymer . 2 residue polymer . # loop_ _ma_model_list.ordinal_id _ma_model_list.model_id _ma_model_list.model_group_id _ma_model_list.model_name _ma_model_list.model_group_name _ma_model_list.assembly_id _ma_model_list.data_id _ma_model_list.model_type _ma_model_list.model_type_other_details 1 1 1 'Best scoring model' 'All models' 1 4 'Homology model' . # loop_ _ma_qa_metric.id _ma_qa_metric.name _ma_qa_metric.description _ma_qa_metric.type _ma_qa_metric.mode _ma_qa_metric.type_other_details _ma_qa_metric.software_group_id 1 'test local' 'some local score' 'normalized score' per-feature-pair . . # loop_ _ma_qa_metric_feature_pairwise.ordinal_id _ma_qa_metric_feature_pairwise.model_id _ma_qa_metric_feature_pairwise.feature_id_1 _ma_qa_metric_feature_pairwise.feature_id_2 _ma_qa_metric_feature_pairwise.metric_id _ma_qa_metric_feature_pairwise.metric_value 1 1 1 2 1 50.000 """ # Test both ways to make sure features still work if they are # referenced by ID before their type is known for cif in (feat + qa, qa + feat): s, = modelcif.reader.read(StringIO(cif)) mg, = s.model_groups m, = mg q1, = m.qa_metrics self.assertIsInstance(q1, modelcif.qa_metric.FeaturePairwise) self.assertIsInstance(q1, modelcif.qa_metric.NormalizedScore) self.assertIsInstance(q1.feature1, modelcif.PolyResidueFeature) self.assertIsInstance(q1.feature2, modelcif.PolyResidueFeature) self.assertAlmostEqual(q1.value, 50.0, delta=1e-6) def test_alignment_info_details_handler(self): """Test _AlignmentInfoHandler and _AlignmentDetailsHandler""" cif = """ loop_ _ma_alignment_info.alignment_id _ma_alignment_info.data_id _ma_alignment_info.software_group_id _ma_alignment_info.alignment_length _ma_alignment_info.alignment_type _ma_alignment_info.alignment_mode 1 3 1 . 'target-template pairwise alignment' global 2 4 1 . 'target-template pairwise alignment' global 3 5 1 . 'target-template MSA' local # # loop_ _ma_alignment_details.ordinal_id _ma_alignment_details.alignment_id _ma_alignment_details.template_segment_id _ma_alignment_details.target_asym_id _ma_alignment_details.score_type _ma_alignment_details.score_type_other_details _ma_alignment_details.score_value _ma_alignment_details.percent_sequence_identity _ma_alignment_details.sequence_identity_denominator _ma_alignment_details.sequence_identity_denominator_other_details 1 1 1 A 'BLAST e-value' . 1.0 45.000 'Length of the shorter sequence' . 2 2 1 A . . . . . . 3 3 1 A 'HHblits e-value' . 2.0 45.000 'Arithmetic mean sequence length' . # loop_ _ma_alignment.ordinal_id _ma_alignment.alignment_id _ma_alignment.target_template_flag _ma_alignment.sequence 1 1 1 DSYV-ETLD 2 1 2 DMACDTFIK 3 1 1 DSYV-ETLD 4 1 2 DMACDTFIK # loop_ _ma_target_template_poly_mapping.id _ma_target_template_poly_mapping.template_segment_id _ma_target_template_poly_mapping.target_asym_id _ma_target_template_poly_mapping.target_seq_id_begin _ma_target_template_poly_mapping.target_seq_id_end 1 1 A 1 8 2 1 A 1 8 """ s, = modelcif.reader.read(StringIO(cif)) a1, a2, a3, = s.alignments self.assertIs(a1.__class__, a2.__class__) self.assertIsInstance(a1, modelcif.alignment.Global) self.assertIsInstance(a1, modelcif.alignment.Pairwise) p, = a1.pairs self.assertIsInstance(p.score, modelcif.alignment.BLASTEValue) self.assertAlmostEqual(p.score.value, 1.0, delta=1e-6) self.assertIsInstance(p.identity, modelcif.alignment.ShorterSequenceIdentity) self.assertAlmostEqual(p.identity.value, 45.0, delta=1e-6) self.assertIsInstance(p.template, modelcif.TemplateSegment) self.assertEqual(p.template._id, '1') self.assertEqual(p.template.gapped_sequence, 'DMACDTFIK') self.assertIsInstance(p.target, ihm.AsymUnitSegment) self.assertEqual(p.target.asym._id, 'A') self.assertEqual(p.target.gapped_sequence, 'DSYV-ETLD') self.assertEqual(p.target.seq_id_range, (1, 8)) self.assertIsInstance(a3, modelcif.alignment.Local) self.assertIsInstance(a3, modelcif.alignment.Multiple) p, = a2.pairs self.assertIsNone(p.score) self.assertIsNone(p.identity) p, = a3.pairs self.assertIsInstance(p.score, modelcif.alignment.HHblitsEValue) self.assertAlmostEqual(p.score.value, 2.0, delta=1e-6) self.assertIsInstance(p.identity, modelcif.alignment.MeanSequenceIdentity) def test_associated_files(self): """Test _AssociatedHandler and _AssociatedArchiveHandler""" cif = """ loop_ _ma_data.id _ma_data.name _ma_data.content_type _ma_data.content_type_other_details 42 'Model subunit' target . loop_ _ma_target_entity.entity_id _ma_target_entity.data_id _ma_target_entity.origin 1 99 'reference database' loop_ _ma_entry_associated_files.id _ma_entry_associated_files.entry_id _ma_entry_associated_files.file_url _ma_entry_associated_files.file_type _ma_entry_associated_files.file_format _ma_entry_associated_files.file_content _ma_entry_associated_files.details _ma_entry_associated_files.data_id 1 model https://example.com/foo.txt file other other 'test file' . 2 model https://example.com/t.zip archive zip 'archive with multiple files' . . 3 model baz.txt file other other 'test file3' . 4 model baz.cif file cif other 'test mmCIF' . 5 model baz.bcif file bcif other 'test BinaryCIF' 42 # # loop_ _ma_associated_archive_file_details.id _ma_associated_archive_file_details.archive_file_id _ma_associated_archive_file_details.file_path _ma_associated_archive_file_details.file_format _ma_associated_archive_file_details.file_content _ma_associated_archive_file_details.description _ma_associated_archive_file_details.data_id 1 2 bar.txt other other 'test file2' . 2 99 99.txt other other 'test file99' . 3 2 bar.cif cif other 'test mmCIF in zip' . 4 2 bar.bcif bcif 'local pairwise QA scores' 'test BinaryCIF in zip' 99 5 2 bar2.bcif bcif 'QA metrics' 'test BinaryCIF in zip' 99 """ s, = modelcif.reader.read(StringIO(cif)) r1, r2 = s.repositories self.assertEqual(r1.url_root, 'https://example.com') f1, zf = r1.files self.assertIsInstance(f1, modelcif.associated.File) self.assertEqual(f1.path, 'foo.txt') self.assertEqual(f1.details, 'test file') self.assertIsInstance(zf, modelcif.associated.ZipFile) self.assertEqual(zf.path, 't.zip') self.assertIsNone(zf.details) f2, f3, f4, f5 = zf.files self.assertEqual(f2.path, 'bar.txt') self.assertEqual(f2.details, 'test file2') self.assertIsNone(f2.data) self.assertIsInstance(f3, modelcif.associated.CIFFile) self.assertFalse(f3.binary) # QA metrics file using old "local pairwise QA scores" name self.assertIsInstance( f4, modelcif.associated.QAMetricsFile) self.assertEqual(f4.file_content, 'QA metrics') self.assertTrue(f4.binary) self.assertIsInstance(f4.data, modelcif.Entity) self.assertIsInstance( f5, modelcif.associated.QAMetricsFile) self.assertEqual(f5.file_content, 'QA metrics') self.assertTrue(f5.binary) self.assertIsInstance(f5.data, modelcif.Entity) self.assertIsNone(r2.url_root) f3, f4, f5 = r2.files self.assertEqual(f3.path, 'baz.txt') self.assertEqual(f3.details, 'test file3') self.assertIsInstance(f4, modelcif.associated.CIFFile) self.assertFalse(f4.binary) self.assertIsNone(f4.data) self.assertIsInstance(f5, modelcif.associated.CIFFile) self.assertTrue(f5.binary) self.assertEqual(f5.data.__class__, modelcif.data.Data) def test_template_poly_handler(self): """Test _TemplatePolyHandler""" cif = """ loop_ _chem_comp.id _chem_comp.type _chem_comp.name _chem_comp.formula MYTYPE 'D-PEPTIDE LINKING' 'MY CUSTOM COMPONENT' 'C6 H12' MYTYP2 'D-PEPTIDE LINKING' 'MY CUSTOM COMPONENT2' 'C6 H12' # loop_ _ma_template_details.ordinal_id _ma_template_details.template_id _ma_template_details.template_origin _ma_template_details.template_entity_type _ma_template_details.template_trans_matrix_id _ma_template_details.template_data_id _ma_template_details.target_asym_id _ma_template_details.template_label_asym_id _ma_template_details.template_label_entity_id _ma_template_details.template_model_num _ma_template_details.template_auth_asym_id 1 1 'reference database' polymer 1 1 A A . 1 A 2 2 'reference database' polymer 1 1 A A . 1 A 3 3 'reference database' polymer 1 1 A A . 1 A # loop_ _ma_template_poly.template_id _ma_template_poly.seq_one_letter_code _ma_template_poly.seq_one_letter_code_can 1 A(MYTYPE)V AVV 2 A(MYTYP2)V . 3 . . 4 CCC CCC """ s, = modelcif.reader.read(StringIO(cif)) # template_id=4 in template_poly should be ignored t1, t2, t3 = s.templates s1, s2, s3 = t1.entity.sequence self.assertEqual(s1.id, 'ALA') self.assertEqual(s1.code, 'A') # Both one-letter and one-letter-canonical were provided self.assertEqual(s2.id, 'MYTYPE') self.assertEqual(s2.code, 'MYTYPE') self.assertEqual(s2.code_canonical, 'V') # Only one-letter was provided s1, s2, s3 = t2.entity.sequence self.assertEqual(s2.id, 'MYTYP2') self.assertEqual(s2.code, 'MYTYP2') self.assertIsNone(s2.code_canonical) # No sequence provided self.assertEqual(len(t3.entity.sequence), 0) def test_template_non_poly_handler(self): """Test _TemplateNonPolyHandler""" cif = """ loop_ _chem_comp.id _chem_comp.type HEM non-polymer # loop_ _ma_template_details.ordinal_id _ma_template_details.template_id _ma_template_details.template_origin _ma_template_details.template_entity_type _ma_template_details.template_trans_matrix_id _ma_template_details.template_data_id _ma_template_details.target_asym_id _ma_template_details.template_label_asym_id _ma_template_details.template_label_entity_id _ma_template_details.template_model_num _ma_template_details.template_auth_asym_id 1 1 'reference database' polymer 1 1 A A . 1 A # loop_ _ma_template_non_poly.template_id _ma_template_non_poly.comp_id _ma_template_non_poly.details 1 HEM Heme """ s, = modelcif.reader.read(StringIO(cif)) t, = s.templates s1, = t.entity.sequence self.assertEqual(s1.id, 'HEM') self.assertEqual(s1.type, 'non-polymer') self.assertIsInstance(s1, ihm.NonPolymerChemComp) def test_chem_comp_handler(self): """Test ChemCompHandler and ChemCompDescriptorHandler""" cif = """ loop_ _chem_comp.id _chem_comp.type _chem_comp.name _chem_comp.formula _chem_comp.ma_provenance MET 'L-peptide linking' . . . CYS 'D-peptide linking' CYSTEINE . ? ALA 'L-peptide linking' ALANINE . 'CCD Core' MATYPE 'L-PEPTIDE LINKING' 'MODELARCHIVE COMPONENT' . 'CCD MA' MYTYPE 'L-PEPTIDE LINKING' 'MY CUSTOM COMPONENT' . 'CCD local' # loop_ _ma_chem_comp_descriptor.ordinal_id _ma_chem_comp_descriptor.chem_comp_id _ma_chem_comp_descriptor.chem_comp_name _ma_chem_comp_descriptor.type _ma_chem_comp_descriptor.value _ma_chem_comp_descriptor.details _ma_chem_comp_descriptor.software_id 1 MYTYPE 'ignored' 'InChI Key' XDAOLTSRNUSPPH-XMMPIXPASA-N foo 1 2 MYTYPE ? 'IUPAC Name' foobar . . # loop_ _entity_poly_seq.entity_id _entity_poly_seq.num _entity_poly_seq.mon_id _entity_poly_seq.hetero 1 1 MET . 1 2 CYS . 1 3 ALA . 1 4 MATYPE . 1 5 MYTYPE . """ s, = modelcif.reader.read(StringIO(cif)) e1, = s.entities s = e1.sequence self.assertEqual(len(s), 5) self.assertEqual(s[2].ccd, 'core') self.assertEqual(s[3].ccd, 'ma') self.assertEqual(s[4].ccd, 'local') d1, d2 = s[4].descriptors self.assertIsInstance(d1, modelcif.descriptor.InChIKey) self.assertEqual(d1.value, 'XDAOLTSRNUSPPH-XMMPIXPASA-N') self.assertEqual(d1.details, 'foo') self.assertEqual(d1.software._id, '1') self.assertIsInstance(d2, modelcif.descriptor.IUPACName) self.assertEqual(d2.value, 'foobar') self.assertIsNone(d2.details) self.assertIsNone(d2.software) def test_add_to_system(self): """Test adding new mmCIF input to existing System""" s = modelcif.System() e = modelcif.Entity('AHC') e._id = '42' s.entities.append(e) fh = StringIO(""" loop_ _struct_asym.id _struct_asym.entity_id _struct_asym.details A 42 foo B 99 bar """) s2, = modelcif.reader.read(fh, add_to_system=s) self.assertIs(s2, s) self.assertEqual(len(s.asym_units), 2) # asym A should point to existing entity self.assertEqual(s.asym_units[0].id, 'A') self.assertIs(s.asym_units[0].entity, e) def test_audit_revision_handler(self): """Test AuditRevisionHistoryHandler""" # We leverage the support in python-ihm, so only a basic test here cif = """ loop_ _pdbx_audit_revision_history.ordinal _pdbx_audit_revision_history.data_content_type _pdbx_audit_revision_history.major_revision _pdbx_audit_revision_history.minor_revision _pdbx_audit_revision_history.revision_date 40 'Structure model' 1 0 ? 41 'Structure model' 1 0 . 42 'Structure model' 2 0 1979-05-03 """ s, = modelcif.reader.read(StringIO(cif)) r1, r2, r3 = s.revisions self.assertEqual(r3.major, 2) self.assertEqual(r3.minor, 0) self.assertEqual(r3.date, datetime.date(1979, 5, 3)) def test_data_usage_handler(self): """Test DataUsageHandler""" # We leverage the support in python-ihm, so only a basic test here cif = """ loop_ _pdbx_data_usage.id _pdbx_data_usage.type _pdbx_data_usage.details _pdbx_data_usage.url _pdbx_data_usage.name 1 license 'some license' someurl somename """ s, = modelcif.reader.read(StringIO(cif)) d1, = s.data_usage self.assertEqual(d1.details, "some license") def test_atom_site_handler_water(self): """Test AtomSiteHandler reading water molecules""" fh = StringIO(""" loop_ _entity.id _entity.type 1 water loop_ _struct_asym.id _struct_asym.entity_id _struct_asym.details A 1 Water B 1 Water # loop_ _pdbx_nonpoly_scheme.asym_id _pdbx_nonpoly_scheme.entity_id _pdbx_nonpoly_scheme.mon_id _pdbx_nonpoly_scheme.ndb_seq_num _pdbx_nonpoly_scheme.pdb_seq_num _pdbx_nonpoly_scheme.auth_seq_num _pdbx_nonpoly_scheme.auth_mon_id _pdbx_nonpoly_scheme.pdb_strand_id _pdbx_nonpoly_scheme.pdb_ins_code A 1 HOH 1 50 500 HOH A . # loop_ _atom_site.group_PDB _atom_site.id _atom_site.type_symbol _atom_site.label_atom_id _atom_site.label_alt_id _atom_site.label_comp_id _atom_site.label_seq_id _atom_site.auth_seq_id _atom_site.pdbx_PDB_ins_code _atom_site.label_asym_id _atom_site.Cartn_x _atom_site.Cartn_y _atom_site.Cartn_z _atom_site.occupancy _atom_site.label_entity_id _atom_site.auth_asym_id _atom_site.B_iso_or_equiv _atom_site.pdbx_PDB_model_num _atom_site.ihm_model_id HETATM 1 O O . HOH . 40 ? A 10.000 10.000 10.000 . 1 A . 1 1 HETATM 2 O O . HOH . 50 ? A 10.000 10.000 10.000 . 1 A . 1 1 HETATM 3 O O . HOH . 60 . A 20.000 20.000 20.000 . 1 A . 1 1 HETATM 4 O O . HOH . 70 . B 20.000 20.000 20.000 . 1 B . 1 1 """) s, = modelcif.reader.read(fh) m = s.model_groups[0][0] a1, a2, a3, b1 = m._atoms # Should include info from both atom_site and scheme table self.assertEqual(a1.asym_unit.auth_seq_id_map, {1: (40, None), 2: (50, None), 3: (60, None)}) self.assertEqual(a1.asym_unit.orig_auth_seq_id_map, {2: 500}) self.assertEqual(b1.asym_unit.auth_seq_id_map, {1: (70, None)}) self.assertIsNone(b1.asym_unit.orig_auth_seq_id_map) # Should get a WaterAsymUnit, not regular AsymUnit self.assertIsInstance(a1.asym_unit, modelcif.WaterAsymUnit) self.assertIsInstance(b1.asym_unit, modelcif.WaterAsymUnit) # seq_id should be assigned based on atom_site self.assertEqual(a1.seq_id, 1) self.assertEqual(a2.seq_id, 2) self.assertEqual(a3.seq_id, 3) self.assertEqual(b1.seq_id, 1) def test_nonpoly_scheme_handler(self): """Test NonPolySchemeHandler""" fh = StringIO(""" loop_ _chem_comp.id _chem_comp.type _chem_comp.name CA non-polymer 'CALCIUM ION' # loop_ _entity.id _entity.type _entity.pdbx_description 1 non-polymer 'CALCIUM ION entity' 2 non-polymer 'no-chem-comp entity' 3 water 'no-chem-comp water' # loop_ _pdbx_entity_nonpoly.entity_id _pdbx_entity_nonpoly.name _pdbx_entity_nonpoly.comp_id 1 'CALCIUM ION' CA # loop_ _struct_asym.id _struct_asym.entity_id _struct_asym.details A 1 foo B 2 bar C 3 baz # loop_ _pdbx_nonpoly_scheme.asym_id _pdbx_nonpoly_scheme.entity_id _pdbx_nonpoly_scheme.mon_id _pdbx_nonpoly_scheme.ndb_seq_num _pdbx_nonpoly_scheme.pdb_seq_num _pdbx_nonpoly_scheme.auth_seq_num _pdbx_nonpoly_scheme.pdb_strand_id _pdbx_nonpoly_scheme.pdb_ins_code A 1 BAR 1 101 202 . . B 2 BAR 1 1 1 Q X C 3 HOH . 1 1 . . C 3 HOH 2 2 2 . . C 3 HOH 3 5 10 . . C 3 HOH 4 1 20 . . C 3 HOH 5 7 7 . . """) s, = modelcif.reader.read(fh) e1, e2, e3 = s.entities # e1 should have sequence filled in by pdbx_entity_nonpoly self.assertEqual([cc.name for cc in e1.sequence], ['CALCIUM ION']) # e2,e3 should have sequence filled in by pdbx_nonpoly_scheme self.assertEqual([(cc.id, cc.name) for cc in e2.sequence], [('BAR', 'no-chem-comp entity')]) self.assertEqual([(cc.id, cc.name) for cc in e3.sequence], [('HOH', 'WATER')]) asym, a2, a3 = s.asym_units # non-polymers have no seq_id_range self.assertEqual(asym.seq_id_range, (None, None)) self.assertEqual(asym.auth_seq_id_map, {1: (101, None)}) self.assertEqual(asym.residue(1).auth_seq_id, 101) self.assertIsNone(asym.residue(1).ins_code) self.assertEqual(asym.strand_id, asym._id) self.assertIsNone(asym._strand_id) self.assertEqual(asym.orig_auth_seq_id_map, {1: 202}) self.assertEqual(a2.auth_seq_id_map, {1: (1, 'X')}) self.assertEqual(a2.residue(1).auth_seq_id, 1) self.assertEqual(a2.residue(1).ins_code, 'X') self.assertEqual(a2.strand_id, 'Q') self.assertEqual(a2._strand_id, 'Q') self.assertIsNone(a2.orig_auth_seq_id_map) self.assertEqual(a3.auth_seq_id_map, {1: (1, None), 2: (2, None), 3: (5, None), 4: (1, None), 5: (7, None)}) self.assertEqual(a3.orig_auth_seq_id_map, {3: 10, 4: 20}) def test_poly_seq_scheme_handler_offset(self): """Test PolySeqSchemeHandler with constant offset""" fh = StringIO(ASYM_ENTITY + """ loop_ _pdbx_poly_seq_scheme.asym_id _pdbx_poly_seq_scheme.entity_id _pdbx_poly_seq_scheme.seq_id _pdbx_poly_seq_scheme.pdb_seq_num _pdbx_poly_seq_scheme.pdb_strand_id A 1 1 6 A A 1 2 7 A A 1 3 8 A A 1 4 9 A """) s, = modelcif.reader.read(fh) asym, = s.asym_units self.assertEqual(asym.auth_seq_id_map, 5) self.assertIsNone(asym._strand_id) self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)], [6, 7, 8, 9]) self.assertIsNone(asym.orig_auth_seq_id_map) def test_poly_seq_scheme_handler_offset_ins_code(self): """Test PolySeqSchemeHandler with constant offset but inscodes""" fh = StringIO(ASYM_ENTITY + """ loop_ _pdbx_poly_seq_scheme.asym_id _pdbx_poly_seq_scheme.entity_id _pdbx_poly_seq_scheme.seq_id _pdbx_poly_seq_scheme.pdb_seq_num _pdbx_poly_seq_scheme.pdb_strand_id _pdbx_poly_seq_scheme.pdb_ins_code A 1 1 6 A . A 1 2 7 A . A 1 3 8 A . A 1 4 9 A A """) s, = modelcif.reader.read(fh) asym, = s.asym_units self.assertEqual(asym.auth_seq_id_map, {1: (6, None), 2: (7, None), 3: (8, None), 4: (9, 'A')}) self.assertIsNone(asym._strand_id) self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)], [6, 7, 8, 9]) self.assertIsNone(asym.residue(1).ins_code) self.assertEqual(asym.residue(4).ins_code, 'A') self.assertIsNone(asym.orig_auth_seq_id_map) def test_poly_seq_scheme_handler_empty(self): """Test PolySeqSchemeHandler with no poly_seq_scheme""" fh = StringIO(ASYM_ENTITY) s, = modelcif.reader.read(fh) asym, = s.asym_units self.assertEqual(asym.auth_seq_id_map, 0) self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)], [1, 2, 3, 4]) self.assertIsNone(asym.orig_auth_seq_id_map) def test_poly_seq_scheme_handler_nop(self): """Test PolySeqSchemeHandler with a do-nothing poly_seq_scheme""" fh = StringIO(ASYM_ENTITY + """ loop_ _pdbx_poly_seq_scheme.asym_id _pdbx_poly_seq_scheme.entity_id _pdbx_poly_seq_scheme.seq_id _pdbx_poly_seq_scheme.pdb_seq_num A 1 1 1 A 1 2 2 A 1 3 3 """) s, = modelcif.reader.read(fh) asym, = s.asym_units self.assertEqual(asym.auth_seq_id_map, 0) self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)], [1, 2, 3, 4]) self.assertIsNone(asym.orig_auth_seq_id_map) def test_poly_seq_scheme_handler_partial(self): """Test PolySeqSchemeHandler with partial information""" fh = StringIO(ASYM_ENTITY + """ loop_ _pdbx_poly_seq_scheme.asym_id _pdbx_poly_seq_scheme.entity_id _pdbx_poly_seq_scheme.seq_id _pdbx_poly_seq_scheme.pdb_seq_num _pdbx_poly_seq_scheme.auth_seq_num A 1 1 6 . A 1 2 7 9 A 1 3 8 . """) s, = modelcif.reader.read(fh) asym, = s.asym_units # No mapping for residue 4 (and no insertion codes at all) self.assertEqual(asym.auth_seq_id_map, {1: (6, None), 2: (7, None), 3: (8, None)}) self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)], [6, 7, 8, 4]) self.assertIsNone(asym.residue(1).ins_code) self.assertEqual(asym.orig_auth_seq_id_map, {2: 9}) def test_poly_seq_scheme_handler_incon_off(self): """Test PolySeqSchemeHandler with inconsistent offset""" fh = StringIO(ASYM_ENTITY + """ loop_ _pdbx_poly_seq_scheme.asym_id _pdbx_poly_seq_scheme.entity_id _pdbx_poly_seq_scheme.seq_id _pdbx_poly_seq_scheme.pdb_seq_num _pdbx_poly_seq_scheme.pdb_strand_id A 1 1 6 X A 1 2 7 X A 1 3 8 X A 1 4 10 X """) s, = modelcif.reader.read(fh) asym, = s.asym_units self.assertEqual(asym._strand_id, 'X') self.assertEqual(asym.auth_seq_id_map, {1: (6, None), 2: (7, None), 3: (8, None), 4: (10, None)}) self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)], [6, 7, 8, 10]) self.assertIsNone(asym.residue(1).ins_code) self.assertIsNone(asym.orig_auth_seq_id_map) def test_poly_seq_scheme_handler_unknown_auth_seq(self): """Test PolySeqSchemeHandler with explicit unknown auth_seq_num""" fh = StringIO(ASYM_ENTITY + """ loop_ _pdbx_poly_seq_scheme.asym_id _pdbx_poly_seq_scheme.entity_id _pdbx_poly_seq_scheme.seq_id _pdbx_poly_seq_scheme.pdb_seq_num _pdbx_poly_seq_scheme.auth_seq_num _pdbx_poly_seq_scheme.pdb_strand_id A 1 1 1 1 A A 1 2 2 2 A A 1 3 3 ? A A 1 4 4 4 A """) s, = modelcif.reader.read(fh) asym, = s.asym_units self.assertEqual(asym.auth_seq_id_map, 0) self.assertEqual(asym.orig_auth_seq_id_map, {3: ihm.unknown}) def test_poly_seq_scheme_handler_str_seq_id(self): """Test PolySeqSchemeHandler with a non-integer pdb_seq_num""" fh = StringIO(ASYM_ENTITY + """ loop_ _pdbx_poly_seq_scheme.asym_id _pdbx_poly_seq_scheme.entity_id _pdbx_poly_seq_scheme.seq_id _pdbx_poly_seq_scheme.pdb_seq_num _pdbx_poly_seq_scheme.auth_seq_num _pdbx_poly_seq_scheme.pdb_strand_id _pdbx_poly_seq_scheme.pdb_ins_code A 1 1 6 6 ? . A 1 2 7 12 ? . A 1 3 8 24 ? . A 1 4 9A 48A ? . """) s, = modelcif.reader.read(fh) asym, = s.asym_units self.assertIsNone(asym._strand_id) self.assertEqual(asym.auth_seq_id_map, {1: (6, None), 2: (7, None), 3: (8, None), 4: ('9A', None)}) self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)], [6, 7, 8, '9A']) self.assertIsNone(asym.residue(1).ins_code) self.assertIsNone(asym.residue(3).ins_code) self.assertEqual(asym.orig_auth_seq_id_map, {2: 12, 3: 24, 4: '48A'}) if __name__ == '__main__': unittest.main()