def parse_mmtf_header(infile):
"""Parse an MMTF file and return basic header-like information.
Args:
infile (str): Path to MMTF file
Returns:
dict: Dictionary of parsed header
Todo:
- Can this be sped up by not parsing the 3D coordinate info somehow?
- OR just store the sequences when this happens since it is already being parsed.
"""
infodict = {}
mmtf_decoder = mmtf.parse(infile)
infodict['date'] = mmtf_decoder.deposition_date
infodict['release_date'] = mmtf_decoder.release_date
infodict['experimental_method'] = mmtf_decoder.experimental_methods
infodict['resolution'] = mmtf_decoder.resolution
infodict['description'] = mmtf_decoder.title
group_name_exclude = ['HOH']
chem_comp_type_exclude = ['l-peptide linking', 'peptide linking']
chemicals = list(
set([
mmtf_decoder.group_list[idx]['groupName']
for idx in mmtf_decoder.group_type_list
if mmtf_decoder.group_list[idx]['chemCompType'].lower() not in
chem_comp_type_exclude and mmtf_decoder.group_list[idx]
['groupName'] not in group_name_exclude
]))
infodict['chemicals'] = chemicals
return infodict
def test_multi_model_write(self):
"""Test multiple models are written out correctly to MMTF."""
parser = PDBParser()
struc = parser.get_structure("1SSU_mod", "PDB/1SSU_mod.pdb")
io = MMTFIO()
io.set_structure(struc)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
io.save(filename)
struc_back = MMTFParser.get_structure(filename)
dict_back = mmtf.parse(filename)
self.assertEqual(dict_back.num_models, 2)
self.assertEqual(dict_back.num_chains, 4)
self.assertEqual(dict_back.num_groups, 4)
self.assertEqual(dict_back.num_atoms, 4)
self.assertEqual(list(dict_back.x_coord_list),
[-1.058, -0.025, 7.024, 6.259])
self.assertEqual(dict_back.chain_id_list, ["A", "B", "A", "B"])
self.assertEqual(dict_back.chain_name_list, ["A", "B", "A", "B"])
self.assertEqual(dict_back.chains_per_model, [2, 2])
self.assertEqual(len(dict_back.group_list), 1)
self.assertEqual(len(dict_back.group_id_list), 4)
self.assertEqual(len(dict_back.group_type_list), 4)
self.assertEqual(dict_back.groups_per_chain, [1, 1, 1, 1])
self.assertEqual(len(dict_back.entity_list), 4)
finally:
os.remove(filename)
def get_structure(file_path):
"""Get a structrue from a file - given a file path.
:param file_path: the input file path
:return: the structure
"""
decoder = parse(file_path)
return get_from_decoded(decoder)
def round_trip(self,pdb_id):
if _internet_on(BASE_URL):
data_in = fetch(pdb_id)
write_mmtf(pdb_id+".mmtf", data_in, MMTFDecoder.pass_data_on)
data_rt = parse(pdb_id+".mmtf")
self.check_equal(data_in, data_rt)
else:
print("Warning - cannot connect to "+BASE_URL)
def get_structure(file_path):
"""Get a structure from a file - given a file path.
:param file_path: the input file path
:return: the structure
"""
try:
decoder = parse(file_path)
except Exception:
decoder = parse_gzip(file_path)
return get_from_decoded(decoder)
def test_write(self):
"""Test a simple structure object is written out correctly to MMTF."""
parser = MMCIFParser()
struc = parser.get_structure("1A8O", "PDB/1A8O.cif")
io = MMTFIO()
io.set_structure(struc)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
try:
io.save(filename)
struc_back = MMTFParser.get_structure(filename)
dict_back = mmtf.parse(filename)
self.assertEqual(dict_back.structure_id, "1A8O")
self.assertEqual(dict_back.num_models, 1)
self.assertEqual(dict_back.num_chains, 2)
self.assertEqual(dict_back.num_groups, 158)
self.assertEqual(dict_back.num_atoms, 644)
self.assertEqual(len(dict_back.x_coord_list), 644)
self.assertEqual(len(dict_back.y_coord_list), 644)
self.assertEqual(len(dict_back.z_coord_list), 644)
self.assertEqual(len(dict_back.b_factor_list), 644)
self.assertEqual(len(dict_back.occupancy_list), 644)
self.assertEqual(dict_back.x_coord_list[5], 20.022)
self.assertEqual(set(dict_back.ins_code_list), {"\x00"})
self.assertEqual(set(dict_back.alt_loc_list), {"\x00"})
self.assertEqual(list(dict_back.atom_id_list), list(range(1, 645)))
self.assertEqual(list(dict_back.sequence_index_list),
list(range(70)) + [-1] * 88)
self.assertEqual(dict_back.chain_id_list, ["A", "B"])
self.assertEqual(dict_back.chain_name_list, ["A", "A"])
self.assertEqual(dict_back.chains_per_model, [2])
self.assertEqual(len(dict_back.group_list), 21)
self.assertEqual(len(dict_back.group_id_list), 158)
self.assertEqual(len(dict_back.group_type_list), 158)
self.assertEqual(dict_back.groups_per_chain, [70, 88])
self.assertEqual(len(dict_back.entity_list), 2)
self.assertEqual(dict_back.entity_list[0]["type"], "polymer")
self.assertEqual(dict_back.entity_list[0]["chainIndexList"], [0])
self.assertEqual(
dict_back.entity_list[0]["sequence"],
"MDIRQGPKEPFRDYVDRFYKTLRAEQASQEVKNWMTETLLVQNANPDCKTILKALGPGATLEEMMTACQG",
)
self.assertEqual(dict_back.entity_list[1]["type"], "water")
self.assertEqual(dict_back.entity_list[1]["chainIndexList"], [1])
self.assertEqual(dict_back.entity_list[1]["sequence"], "")
finally:
os.remove(filename)
def from_file(cls, filename):
"""
Initialize structure from MMTF file
Parameters
----------
filename : str
Path of MMTF file
Returns
-------
PDB
initialized PDB structure
"""
try:
return cls(parse(filename))
except FileNotFoundError as e:
raise ResourceError(
"Could not find file {}".format(filename)
) from e
def to_mmtf_MMTFDecoder(item,
atom_indices='all',
structure_indices='all',
check=True):
if check:
digest_item(item, 'file:mmtf')
atom_indices = digest_atom_indices(atom_indices)
structure_indices = digest_structure_indices(structure_indices)
from mmtf import parse
from ..mmtf_MMTFDecoder import extract as extract_mmtf_MMTFDecoder
tmp_item = parse(item)
tmp_item = extract_mmtf_MMTFDecoder(tmp_item,
atom_indices=atom_indices,
structure_indices=structure_indices,
copy_if_all=False,
check=False)
return tmp_item
def test_selection_write(self):
"""Test the use of a Select subclass when writing MMTF files."""
struc = MMTFParser.get_structure("PDB/4CUP.mmtf")
io = MMTFIO()
io.set_structure(struc)
filenumber, filename = tempfile.mkstemp()
os.close(filenumber)
class CAonly(Select):
"""Accepts only CA residues."""
def accept_atom(self, atom):
if atom.name == "CA" and atom.element == "C":
return 1
try:
io.save(filename, CAonly())
struc_back = MMTFParser.get_structure(filename)
dict_back = mmtf.parse(filename)
self.assertEqual(dict_back.num_atoms, 116)
self.assertEqual(len(dict_back.x_coord_list), 116)
self.assertEqual(set(dict_back.alt_loc_list), {"\x00", "A", "B"})
finally:
os.remove(filename)
def test_round_trip(self):
data_in = parse_gzip("mmtf/tests/testdatastore/4CUP.mmtf.gz")
write_mmtf("test.mmtf", data_in, MMTFDecoder.pass_data_on)
data_rt = parse("test.mmtf")
self.check_equal(data_in, data_rt)
def _parse_mmtf(fn):
if fn.endswith('gz'):
return mmtf.parse_gzip(fn)
else:
return mmtf.parse(fn)
def setUp(self, mock_fetch):
top = mmtf.parse(MMTF)
mock_fetch.return_value = top
self.u = mda.fetch_mmtf('173D') # string is irrelevant
def setUp(self):
top = mmtf.parse(MMTF)
self.u = mda.Universe(top)
def u(self):
top = mmtf.parse(MMTF)
with mock.patch('mmtf.fetch') as mock_fetch:
mock_fetch.return_value = top
return mda.fetch_mmtf('173D') # string is irrelevant
def test_encoder(self):
decoded = parse("mmtf/tests/testdatastore/4CUP.mmtf")
decoded.encode_data()
def test_round_trip(self):
decoded = parse("mmtf/tests/testdatastore/4CUP.mmtf")
packed = decoded.get_msgpack()
decoded.decode_data(msgpack.unpackb(packed))
def test_decoder(self):
decoded = parse("mmtf/tests/testdatastore/4CUP.mmtf")
def u(self):
top = mmtf.parse(MMTF)
with mock.patch('mmtf.fetch') as mock_fetch:
mock_fetch.return_value = top
return mda.fetch_mmtf('173D') # string is irrelevant
def u(self):
return mda.Universe(mmtf.parse(MMTF))
def u(self):
return mda.Universe(mmtf.parse(MMTF))
def _parse_mmtf(fn):
if fn.endswith('gz'):
return mmtf.parse_gzip(fn)
else:
return mmtf.parse(fn)
def round_trip(self,pdb_id):
data_in = fetch(pdb_id)
write_mmtf(pdb_id+".mmtf", data_in, MMTFDecoder.pass_data_on)
data_rt = parse(pdb_id+".mmtf")
self.check_equal(data_in, data_rt)
