def patch_swf(target_site, swf_path): swf_name = os.path.splitext(os.path.basename(swf_path))[0] try: abc_index = target_site.PATCH_TARGET_ABC_INDEX except AttributeError: abc_index = 0 abc_id = '%s-%d' % (swf_name, abc_index) try: os.remove(full_path('%s.abc' % abc_id)) shutil.rmtree(full_path(abc_id)) except OSError as e: if e.errno != errno.ENOENT: raise run(['abcexport', full_path('%s.swf' % swf_name)]) run(['rabcdasm', full_path('%s.abc' % abc_id)]) with cd(full_path(abc_id)): run([ 'patch', '-i', os.path.join('..', target_site.PATCH_FILENAME), '-p0']) run(['rabcasm', full_path('%s/%s.main.asasm' % (abc_id, abc_id))]) run([ 'abcreplace', full_path('%s.swf' % swf_name), str(abc_index), full_path('%s/%s.main.abc' % (abc_id, abc_id))])
def __init__(self, *args, **kwargs): swf_path = kwargs['swf_path'] del kwargs['swf_path'] self.swf_url = kwargs['swf_url'] del kwargs['swf_url'] self.collected_data = kwargs['collected_data'] del kwargs['collected_data'] self.target_site = kwargs['target_site'] del kwargs['target_site'] self.files_dict = { '/proxy.pac': full_path('proxy.pac'), self.swf_url: full_path(swf_path), } super(Handler, self).__init__(*args, **kwargs)
def test_read_1pfe_cif(self): st = gemmi.read_structure(full_path('1pfe.cif.gz')) self.check_1pfe(st) # write structure to cif and read it back out_name = get_path_for_tempfile(suffix='.cif') st.make_mmcif_document().write_file(out_name) st2 = gemmi.read_structure(out_name) os.remove(out_name) self.check_1pfe(st2)
def test_ncs(self): st = gemmi.read_structure(full_path('5cvz_final.pdb')) self.assertEqual(st.resolution, 3.29) first_atom = st[0].sole_residue('A', gemmi.SeqId(17, ' '))[0] ne2 = st[0].sole_residue('A', gemmi.SeqId('63')).sole_atom('NE2') direct_dist = first_atom.pos.dist(ne2.pos) self.assertAlmostEqual(direct_dist, 34.89, delta=1e-2) nearest_image = st.cell.find_nearest_image(first_atom.pos, ne2.pos) nearest_dist = nearest_image.dist() self.assertAlmostEqual(nearest_dist, 8.02, delta=1e-2)
def test_assembly_naming(self): st = gemmi.read_structure(full_path('4oz7.pdb')) model = st[0] a1 = st.assemblies[1] bio = a1.make_assembly(model, gemmi.HowToNameCopiedChains.AddNumber) self.assertEqual([ch.name for ch in bio], ['B1']) bio = a1.make_assembly(model, gemmi.HowToNameCopiedChains.Dup) self.assertEqual([ch.name for ch in bio], ['B']) bio = a1.make_assembly(model, gemmi.HowToNameCopiedChains.Short) self.assertEqual([ch.name for ch in bio], ['B'])
def test_software_category(self): doc = gemmi.cif.read_file(full_path('3dg1_final.cif')) input_block = doc.sole_block() st = gemmi.make_structure_from_block(input_block) output_block = st.make_mmcif_document().sole_block() software = output_block.get_mmcif_category('_software') del software['date'] assert software['version'][0] is False software['version'][0] = None self.assertEqual(input_block.get_mmcif_category('_software'), software)
def test_extract_sequence_info(self): st = gemmi.read_structure(full_path('5cvz_final.pdb')) st.add_entity_types() polymer = st[0][0].get_polymer() self.assertEqual(polymer.check_polymer_type(), gemmi.PolymerType.PeptideL) expected = ('AAATSLVYDTCYVTLTERATTSFQRQSFPTLKGMGDRAFQVVAFTIQGVS' 'AAPLMYNARLYNPGDTDSVHATGVQLMGTVPRTVRLTPRVGQNNWFFGNT' 'EEAETILAIDGLVSTKGANAPSNTVIVTGCFRLAPSELQSS') self.assertEqual(polymer.make_one_letter_sequence(), expected)
def test_remove2(self): model = gemmi.read_structure(full_path('1pfe.cif.gz'))[0] self.assertEqual(len(model), 2) del model['A'] self.assertEqual(len(model), 1) b = model['B'] self.assertEqual(b[0].name, 'DSN') del b['1']['DSN'] self.assertEqual(b[0].name, 'ALA') del b[0] self.assertEqual(b[0].name, 'N2C')
def test_3dg1(self): st = gemmi.read_structure(full_path('3dg1_final.cif')) self.assertEqual(st.info['_entry.id'], '3DG1') self.assertEqual(len(st[0]), 1) chain = st[0]['A'] for res in chain[-2:]: self.assertEqual(res.name, 'HOH') for res in chain: for atom in res: n_images = st.cell.is_special_position(atom.pos) self.assertEqual(atom.occ * (n_images + 1), 1.0)
def test_4hhh_frag(self): path = full_path('4hhh_frag.pdb') with open(path) as f: frag = f.read() st = gemmi.read_pdb_string(frag) in_headers = frag.splitlines() out_headers = st.make_pdb_headers().splitlines() self.assertEqual(in_headers[0], out_headers[0]) # the difference 4555 vs 2555 doesn't matter for us self.assertEqual(in_headers[1], out_headers[1].replace(' 4555 ', ' 2555 ')) self.assertEqual(in_headers[2], out_headers[2])
def test_read_write(self): path = full_path('5e5z.mtz') mtz = gemmi.read_mtz_file(path) self.assertEqual(mtz.spacegroup.hm, 'P 1 21 1') out_name = get_path_for_tempfile() mtz.write_to_file(out_name) mtz2 = gemmi.read_mtz_file(out_name) os.remove(out_name) self.assertEqual(mtz2.spacegroup.hm, 'P 1 21 1') if numpy is not None: self.assert_numpy_equal(numpy.array(mtz, copy=False), mtz.array) self.assert_numpy_equal(mtz.array, mtz2.array)
def get_swf(): print('Downloading the page %s' % PAGE_URL) urlh = compat_urllib_request_urlopen(PAGE_URL) webpage = urlh.read().decode('utf-8') urlh.close() mobj = re.search(r'http://[^\'"]+MainPlayer[^.]+\.swf', webpage) swf_url = mobj.group(0) swf_path = full_path(os.path.basename(swf_url)) print('SWF URL is %s' % swf_url) compat_urllib_request_urlretrieve(swf_url, filename=swf_path) return swf_path, swf_url
def test_ignore_flag(self): st = gemmi.read_structure(full_path('4oz7.pdb')) st.setup_entities() ns = gemmi.NeighborSearch(st[0], st.cell, 5).populate() cs = gemmi.ContactSearch(4.0) cs.ignore = gemmi.ContactSearch.Ignore.SameResidue results = cs.find_contacts(ns) self.assertEqual(len(results), 607) cs.ignore = gemmi.ContactSearch.Ignore.SameChain results = cs.find_contacts(ns) self.assertEqual(len(results), 190) self.assertTrue( all(r.image_idx != 0 or r.partner1.chain is not r.partner2.chain for r in results))
def test_reading(self): m = gemmi.read_ccp4_map(full_path('5i55_tiny.ccp4')) self.assertEqual(m.grid.nu, 8) self.assertEqual(m.grid.nv, 6) self.assertEqual(m.grid.nw, 10) self.assertEqual(m.header_i32(28), 0) m.set_header_i32(28, 20140) # set NVERSION self.assertEqual(m.header_i32(28), 20140) dmax = m.header_float(21) self.assertEqual(dmax, max(p.value for p in m.grid)) self.assertNotEqual(m.grid.axis_order, gemmi.AxisOrder.XYZ) m.setup() self.assertEqual(m.grid.axis_order, gemmi.AxisOrder.XYZ) self.assertEqual(m.grid.nu, 60) self.assertEqual(m.grid.nv, 24) self.assertEqual(m.grid.nw, 60) self.assertEqual(m.grid.point_count, 60 * 24 * 60) self.assertEqual(m.header_float(14), 90.0) # 14 - alpha angle self.assertEqual(m.grid.unit_cell.alpha, 90.0) self.assertEqual(m.grid.spacegroup.ccp4, 4) # P21 pos = gemmi.Position(19.4, 3., 21.) frac = m.grid.unit_cell.fractionalize(pos) pos_value = 2.1543798446655273 self.assertAlmostEqual(m.grid.interpolate_value(pos), pos_value) self.assertAlmostEqual(m.grid.interpolate_value(frac), pos_value) # this spacegroup has symop -x, y+1/2, -z m.grid.set_value(60 - 3, 24 // 2 + 4, 60 - 5, 100) # image of (3, 4, 5) self.assertEqual(m.grid.get_value(60 - 3, 24 // 2 + 4, 60 - 5), 100) self.assertTrue(math.isnan(m.grid.get_value(3, 4, 5))) m.grid.symmetrize_max() self.assertEqual(m.grid.get_value(3, 4, 5), 100) m.grid.set_value(3, 4, 5, float('nan')) self.assertTrue(math.isnan(m.grid.get_value(3, 4, 5))) m.grid.symmetrize_min() self.assertEqual(m.grid.get_value(3, 4, 5), 100) m.grid.set_value(60 - 3, 24 // 2 + 4, 60 - 5, float('nan')) m.grid.symmetrize_max() self.assertEqual(m.grid.get_value(60 - 3, 24 // 2 + 4, 60 - 5), 100) if numpy: arr = numpy.array(m.grid, copy=False) self.assertEqual(arr.shape, (60, 24, 60)) self.assertEqual(arr[3][4][5], 100) grid2 = gemmi.FloatGrid(arr) self.assertTrue( numpy.allclose(m.grid, grid2, atol=0.0, rtol=0, equal_nan=True))
def get_swf(target_site): swf_url = target_site.get_site_swf() parts = compat_urlparse.urlparse(swf_url) swf_path = full_path(os.path.basename(parts.path)) urlh = compat_urllib_request.urlopen(swf_url) with open(swf_path, 'wb') as f: f.write(urlh.read()) if hasattr(target_site, 'decrypt_swf'): old_swf_path = swf_path swf_path = os.path.splitext(swf_path)[0] + '_decrypted.swf' decrypted_swf = target_site.decrypt_swf(read_file(old_swf_path)) write_file(swf_path, decrypted_swf) return swf_path, swf_url
def test_scaling(self): doc = gemmi.cif.read(full_path('r5wkdsf.ent')) rblock = gemmi.as_refln_blocks(doc)[0] fobs_data = rblock.get_value_sigma('F_meas_au', 'F_meas_sigma_au') if numpy: self.assertEqual(fobs_data.value_array.shape, (367, )) # without mask fc_data = rblock.get_f_phi('F_calc_au', 'phase_calc') scaling = gemmi.Scaling(fc_data.unit_cell, fc_data.spacegroup) scaling.prepare_points(fc_data, fobs_data) scaling.fit_isotropic_b_approximately() scaling.fit_parameters() #print(scaling.k_overall, scaling.b_overall) scaling.scale_data(fc_data)
def __init__(self, *args, **kwargs): self.swf_path = kwargs['swf_path'] del kwargs['swf_path'] self.collected_data = kwargs['collected_data'] del kwargs['collected_data'] files = [self.swf_path, '/proxy.pac'] self.files_dict = { filename: full_path(os.path.basename(filename)) for filename in files } super(Handler, self).__init__(*args, **kwargs)
def test_ncs(self): st = gemmi.read_structure(full_path('5cvz_final.pdb')) self.assertEqual(st.resolution, 3.29) first_atom = st[0].sole_residue('A', gemmi.SeqId(17, ' '))[0] ne2 = st[0].sole_residue('A', gemmi.SeqId('63')).sole_atom('NE2') direct_dist = first_atom.pos.dist(ne2.pos) self.assertAlmostEqual(direct_dist, 34.89, delta=1e-2) nearest_image = st.cell.find_nearest_image(first_atom.pos, ne2.pos) nearest_dist = nearest_image.dist() self.assertAlmostEqual(nearest_dist, 8.02, delta=1e-2) # test __getitem__(splice) - unrelated to NCS (sometimes we put # unrelated tests together to avoid the same file again) chain = st[0]['A'] res = chain.next_residue(chain[:5][0]) self.assertTrue(res is chain[1])
def test_superposition(self): model = gemmi.read_structure(full_path('4oz7.pdb'))[0] poly1 = model['A'].get_polymer() poly2 = model['B'].get_polymer() ptype = poly1.check_polymer_type() S = gemmi.SupSelect s1 = gemmi.calculate_superposition(poly1, poly2, ptype, S.CaP) s2 = gemmi.calculate_superposition(poly1, poly2, ptype, S.MainChain) s3 = gemmi.calculate_superposition(poly1, poly2, ptype, S.All) self.assertEqual(s1.count, 10) self.assertEqual(s2.count, 39) self.assertEqual(s3.count, 77) self.assertAlmostEqual(s1.rmsd, 0.146, places=3) self.assertAlmostEqual(s2.rmsd, 0.174, places=3) self.assertAlmostEqual(s3.rmsd, 0.400, places=3) for s in [s1, s2, s3]: self.assertAlmostEqual(s.transform.vec.y, 17.0, places=1)
def test_rnase_predefined_removals(self, add_entities=False): st = gemmi.read_structure(full_path('rnase_frag.pdb')) if add_entities: self.assertEqual(len(st.entities), 0) st.assign_subchains() st.ensure_entities() self.assertEqual(len(st.entities), 4) model = st[0] nres_a = len(model['A']) nres_b = len(model['B']) st.remove_ligands_and_waters() # removes SO4 from each chain self.assertEqual(len(model['A']), nres_a - 1) self.assertEqual(len(model['B']), nres_b - 1) self.assertEqual(len(model['W']), 0) self.assertEqual(len(model), 3) st.remove_empty_chains() self.assertEqual(len(model), 2)
def test_f_phi_grid(self): path = full_path('5wkd_phases.mtz.gz') mtz = gemmi.read_mtz_file(path) size = mtz.get_size_for_hkl() for half_l in (False, True): grid1 = mtz.get_f_phi_on_grid('FWT', 'PHWT', size, half_l=half_l) grid2 = mtz.get_f_phi_on_grid('FWT', 'PHWT', size, half_l=half_l, order=gemmi.AxisOrder.ZYX) if numpy is None: continue array1 = numpy.array(grid1, copy=False) array2 = numpy.array(grid2, copy=False) self.assertTrue((array2 == array1.transpose(2, 1, 0)).all()) fft_test(self, mtz, 'FWT', 'PHWT', size)
def test_previous_next_residue(self): st = gemmi.read_structure(full_path('1pfe.cif.gz'), merge_chain_parts=False) chain_b = st[0]['B'] res = chain_b['6']['ALA'] res = chain_b.next_residue(res) self.assertEqual(res.name, 'NCY') res = chain_b.next_residue(res) self.assertEqual(res.name, 'MVA') self.assertIsNone(chain_b.next_residue(res)) res = chain_b.previous_residue(res) self.assertEqual(res.name, 'NCY') res = chain_b.previous_residue(res) self.assertEqual(res.name, 'ALA') res = chain_b.next_residue(chain_b['7']['N2C']) self.assertEqual(res.name, 'MVA') self.assertEqual(chain_b.previous_residue(res).name, 'NCY') self.assertIsNone(chain_b.previous_residue(chain_b[0]))
def patch_swf(swf_path): swf_name = os.path.splitext(os.path.basename(swf_path))[0] abc_index = 0 abc_id = '%s-%d' % (swf_name, abc_index) try: os.remove(full_path('%s.abc' % abc_id)) shutil.rmtree(full_path(abc_id)) except OSError as e: if e.errno != errno.ENOENT: raise run(['abcexport', full_path('%s.swf' % swf_name)]) run(['rabcdasm', full_path('%s.abc' % abc_id)]) subprocess.Popen([ 'patch', '-p0', '-i', '../asasm.patch'], cwd=full_path(abc_id)).wait() run(['rabcasm', full_path('%s/%s.main.asasm' % (abc_id, abc_id))]) run([ 'abcreplace', full_path('%s.swf' % swf_name), str(abc_index), full_path('%s/%s.main.abc' % (abc_id, abc_id))])
def test_remove_and_add_column(self): path = full_path('5e5z.mtz') col_name = 'FREE' mtz = gemmi.read_mtz_file(path) col = mtz.column_with_label(col_name) col_idx = col.idx ncol = len(mtz.columns) if numpy is None: return self.assert_numpy_equal(col.array, numpy.array(col, copy=False)) arr = col.array.copy() mtz_data = numpy.array(mtz, copy=True) self.assertEqual(mtz_data.shape, (mtz.nreflections, ncol)) mtz.remove_column(col_idx) self.assertEqual(len(mtz.columns), ncol - 1) self.assertEqual( numpy.array(mtz, copy=False).shape, (mtz.nreflections, ncol - 1)) col = mtz.add_column(col_name, 'I', dataset_id=0, pos=col_idx) numpy.array(col, copy=False)[:] = arr self.assert_numpy_equal(mtz_data, numpy.array(mtz, copy=False))
def test_read_write_5cvz_final(self, via_cif=False): path = full_path('5cvz_final.pdb') with open(path) as f: expected = [line.rstrip() for line in f if is_written_to_pdb(line, via_cif) # SCALE is not written b/c CRYST1 has more precision. and line[:5] != 'SCALE'] st = gemmi.read_structure(path) if via_cif: # input file w/o TER record -> subchains not setup automatically st.setup_entities() doc = st.make_mmcif_document() st = gemmi.make_structure_from_block(doc[0]) out_lines = self.write_and_read(st, via_cif=False) if via_cif: out_lines = [line for line in out_lines # input file has no REMARK 2, but it gets generated # from REMARK 3 when going pdb->cif->pdb if line[:10] != 'REMARK 2' and line[:5] != 'TER '] self.assertEqual(expected, [line.rstrip() for line in out_lines])
def test_remove2(self): model = gemmi.read_structure(full_path('1pfe.cif.gz'))[0] self.assertEqual(len(model), 2) del model['A'] self.assertEqual(len(model), 1) b = model['B'] self.assertEqual(b[0].name, 'DSN') del b['1']['DSN'] self.assertEqual(b[0].name, 'ALA') del b[0] self.assertEqual(b[0].name, 'N2C') # test append_residues() self.assertEqual(len(b), 20) b.append_residues(b[:5], min_sep=10) self.assertEqual(len(b), 25) # test append_residues() with empty chain new_chain = gemmi.Chain('X') new_chain.append_residues(b[:5], min_sep=1) self.assertEqual(len(new_chain), 5)
def patch_swf(swf_path): swf_name = os.path.splitext(os.path.basename(swf_path))[0] abc_index = 0 abc_id = '%s-%d' % (swf_name, abc_index) try: os.remove(full_path('%s.abc' % abc_id)) shutil.rmtree(full_path(abc_id)) except OSError as e: if e.errno != errno.ENOENT: raise run(['abcexport', full_path('%s.swf' % swf_name)]) run(['rabcdasm', full_path('%s.abc' % abc_id)]) subprocess.Popen(['patch', '-p0', '-i', '../asasm.patch'], cwd=full_path(abc_id)).wait() run(['rabcasm', full_path('%s/%s.main.asasm' % (abc_id, abc_id))]) run([ 'abcreplace', full_path('%s.swf' % swf_name), str(abc_index), full_path('%s/%s.main.abc' % (abc_id, abc_id)) ])
def test_read_1orc(self): st = gemmi.read_structure(full_path('1orc.pdb')) self.assertEqual(st.resolution, 1.54) self.assertAlmostEqual(st.cell.a, 34.77) self.assertEqual(st.cell.alpha, 90) self.assertEqual(len(st.ncs), 0) model = st[0] self.assertEqual(len(model), 1) self.assertEqual(len(model.subchains()), 2) A = model['A'] waters = A.get_waters() self.assertEqual(len(waters), 57) # FORMUL 2 HOH *57(H2 O) self.assertTrue(all(res.name == 'HOH' for res in waters)) self.assertTrue(A['3']) self.assertFalse(A['0']) self.assertEqual([res.seqid.num for res in A if res.seqid.icode != ' '], [56] * 5) self.assertEqual(len(A['55']), 1) self.assertEqual(len(A['55B']), 0) self.assertEqual(len(A['56B']), 1) self.assertEqual(A['56'][0].seqid.icode, ' ') self.assertEqual(A['56c'][0].seqid.icode, 'C')
def test_assembly(self): st = gemmi.read_structure(full_path('1pfe.cif.gz'), merge_chain_parts=False) model = st[0] self.assertEqual([ch.name for ch in model], ['A', 'B', 'A', 'B', 'A', 'B']) a_mass = sum(ch.calculate_mass() for ch in model if ch.name == 'A') b_mass = sum(ch.calculate_mass() for ch in model if ch.name == 'B') model_mass = model.calculate_mass() self.assertAlmostEqual(model_mass, a_mass + b_mass) self.assertEqual(len(st.assemblies), 1) asem = st.assemblies[0] bio = asem.make_assembly(model, gemmi.HowToNameCopiedChains.Short) self.assertEqual([ch.name for ch in bio], ['A', 'B', 'C', 'D']) self.assertAlmostEqual(bio.calculate_mass(), 2 * model_mass) self.assertAlmostEqual(bio[0].calculate_mass(), a_mass) self.assertAlmostEqual(bio[1].calculate_mass(), b_mass) self.assertAlmostEqual(bio[2].calculate_mass(), a_mass) self.assertAlmostEqual(bio[3].calculate_mass(), b_mass) bio = asem.make_assembly(model, gemmi.HowToNameCopiedChains.AddNumber) self.assertEqual([ch.name for ch in bio], ['A1', 'B1', 'A2', 'B2'])
def main(): args = docopt(__doc__) config_filename = common.full_path(args['<configfile>']) yaml_config = common.read_config_file(config_filename) configs = load_nginx_config_table(yaml_config) template_mgr = common.get_template_mgr_for_location('templates') config_template = template_mgr.get_template('nginx_config.j2') # show all the configurations # if args['-l'] or args['--list']: for key in configs.keys(): print(configs[key]) exit(0) # we can generate without a specific nginx config, iff there's just one # output = None config_name = args['--env'] if args['<configfile>'] and not config_name: if len(configs.keys()) > 1: print('Multiple configurations found. Please specify one.') exit(0) output = config_template.render(nginx_config=configs.values()[0]) else: if not configs.get(config_name): print('No nginx configuration labeled "%s" in %s.' % (config_name, config_filename)) exit(0) output = config_template.render(nginx_config=configs[config_name]) print(output) exit(0)
def main(): args = docopt(__doc__) config_filename = common.full_path(args['<configfile>']) yaml_config = common.read_config_file(config_filename) configs = load_nginx_config_table(yaml_config) template_mgr = common.get_template_mgr_for_location('templates') config_template = template_mgr.get_template('nginx_config.j2') # show all the configurations # if args['-l'] or args['--list']: for key in configs.keys(): print configs[key] exit(0) # we can generate without a specific nginx config, iff there's just one # output = None config_name = args['--env'] if args['<configfile>'] and not config_name: if len(configs.keys()) > 1: print 'Multiple configurations found. Please specify one.' exit(0) output = config_template.render(nginx_config=configs.values()[0]) else: if not configs.get(config_name): print 'No nginx configuration labeled "%s" in %s.' % (config_name, config_filename) exit(0) output = config_template.render(nginx_config=configs[config_name]) print output exit(0)
def test_5i55_predefined_removals(self, clear_entities=False): st = gemmi.read_structure(full_path('5i55.cif')) if clear_entities: self.assertEqual(len(st.entities), 4) st.entities = gemmi.EntityList() self.assertEqual(len(st.entities), 0) lys12 = st[0]['A']['12']['LYS'] count_b = sum(a.altloc == 'B' for a in lys12) model = st[0] # one author-chain and 4 label-chains: AA, 2 x ligand, waters self.assertEqual(len(model), 1) self.assertEqual(len(model.subchains()), 4) n_waters = len(model.get_subchain('D')) n_sites = model.count_atom_sites() occ_sum = model.count_occupancies() self.assertEqual(n_sites, occ_sum + count_b) st.remove_waters() self.assertEqual(len(model.subchains()), 3) self.assertEqual(model.count_atom_sites(), n_sites - n_waters) self.assertEqual(model.count_occupancies(), occ_sum - n_waters) st.remove_empty_chains() self.assertEqual(len(model.subchains()), 3) n_res = len(model['A']) st.remove_ligands_and_waters() self.assertEqual(len(model['A']), n_res - 2) mse = model['A'][0] self.assertEqual(len(mse), 8) mse.trim_to_alanine() self.assertEqual([a.name for a in mse], ['N', 'CA', 'C', 'O', 'CB']) model['A'].trim_to_alanine() # ALA has 5 atoms, except the last one which has OXT (hence +1) expected_count = sum(4 + (r.name != 'GLY') for r in model['A']) + 1 self.assertEqual(model.count_occupancies(), expected_count) st.remove_alternative_conformations() self.assertEqual(model.count_occupancies(), expected_count - 5 / 2.) self.assertTrue(not any(a.has_altloc() for a in lys12))
def test_remove2(self): st = gemmi.read_structure(full_path('1pfe.cif.gz')) model = st[0] self.assertEqual(len(model), 2) b = model['B'] self.assertEqual(b[0].name, 'DSN') del b['1']['DSN'] self.assertEqual(b[0].name, 'ALA') del b[0] self.assertEqual(b[0].name, 'N2C') # test append_residues() self.assertEqual(len(b), 20) b.append_residues(b[:5], min_sep=10) self.assertEqual(len(b), 25) # test append_residues() with empty chain new_chain = gemmi.Chain('X') new_chain.append_residues(b[:5], min_sep=1) self.assertEqual(len(new_chain), 5) # test adding and removing chains model.add_chain(new_chain, unique_name=False) model.add_chain(new_chain, unique_name=True) model.add_chain(new_chain) self.assertEqual([chain.name for chain in model], list('ABXCX')) del model[2:] model.add_chain(new_chain, unique_name=True) self.assertEqual([chain.name for chain in model], list('ABX')) del model[-1] del model['A'] self.assertEqual(len(model), 1) self.assertEqual(model[0].name, 'B') doc = st.make_mmcif_document() ref_seq = doc[0].get_mmcif_category('_struct_ref_seq') self.assertEqual(ref_seq['pdbx_strand_id'], ['B'])