def test_mdtraj_to_fasta():
import mdtraj as md
topology = md.load(u.relative_to(__file__, 'data/p3_p4.pdb')).topology
chain_A = u.mdtraj_to_fasta(topology, 0)
chain_B = u.mdtraj_to_fasta(topology, 1)
assert chain_A == "IQQLEEEIAQLEQKNAALKEKNQALKYG"
assert chain_B == "IAQLKQKIQALKQENQQLEEENAALEYG"
def test_sequnce_and_knowns_spaces():
aln_file = u.relative_to(__file__, 'data/test-aln-spaces.ali')
seq, knowns = u.sequnce_and_knowns(aln_file)
assert seq == 'tet-p5LD3'
#use set so order is not important
assert set(knowns) == set(
['p3_p4', 'p5_p6', 'p7_p8', 'APHshort', 'BCRshort', 'GCN'])
def writepdb():
import mdtraj as md
import os
pdbname = u.relative_to(__file__, 'data/APH.pdb')
pdbname1 = u.relative_to(__file__, 'data/APH1.pdb')
md_obj = md.load(pdbname)
topology = md_obj.topology
positions = md_obj.xyz
seq_target = u.mdtraj_to_fasta(topology, 0)[2:17]
u.writepdb(2, 14, topology, positions, pdbname, 1, 2)
assert os.path.isfile(pdbname1)
md_obj = md.load(pdbname1)
topology = md_obj.topology
seq_test = u.mdtraj_to_fasta(topology, 0)
assert seq_test == seq_target
def test_mdtraj_to_fasta_bcr():
"""Test for reading MSE residue"""
import mdtraj as md
topology = md.load(u.relative_to(__file__, 'data/BCR.pdb')).topology
chain_A = u.mdtraj_to_fasta(topology, 0)
chain_B = u.mdtraj_to_fasta(topology, 1)
assert chain_A == "DIEQELERAKASIRRLEQEVNQERFRMIYLQTLLAK"
assert chain_B == "DIEQELERAKASIRRLEQEVNQERFRMIYLQTLLAK"
def test_seq_to_seq_map():
assert seq_to_seq_map({
'1': 'ABC',
'2': 'CDEF'
}) == {
'1': 'ABC',
'2': 'CDEF'
}
xls_file = u.relative_to(__file__, 'data/segments.xlsx')
assert seq_to_seq_map(xls_file) == \
{u'P1SN': u'SPED EIRQLEQ ENSQLER ENQRLEQ EIYQLER',
u'P2SN': u'SPED KIEELKE KNSQLKE KNEELKQ KIYELKE',
u'P3SN': u'SPED EIQQLEE EISQLEQ KNSELKE KNQELKY',
u'P4SN': u'SPED KISQLKE KIQQLKQ ENQQLEE ENSQLEY',
u'longTE': u'SPED KISQLKE KIQQLKQ ENQQLEE ENSQLEY ENQQLEE ENSQLEY'}
def test_get_annotated_sequence():
xls_file = u.relative_to(__file__, 'data/segments.xlsx')
#TODO increase readibility
result = """M
SPED EIRQLEQ ENSQLER ENQRLEQ EIYQLER\t|P1SN
GSGPG
SPED EIQQLEE EISQLEQ KNSELKE KNQELKY\t|P3SN
GSGPG
SPED KISQLKE KIQQLKQ ENQQLEE ENSQLEY\t|P4SN
GSGPG
SPED KIEELKE KNSQLKE KNEELKQ KIYELKE\t|P2SN
LEHHHHHHHH"""
annotated_seq = get_annotated_sequence("P1SN-P3SN-P4SN-P2SN".split("-"),
xls_file,
linkers="GSGPG",
N_tag="M",
C_tag="LEHHHHHHHH")
assert annotated_seq == result
log.verbose() # request verbose output
if args.out_dir is None:
args.out_dir = d.name + u.id_generator()
if not os.path.exists(args.out_dir):
os.makedirs(args.out_dir)
#convert to absolute path before chdir
args.alnfile = os.path.abspath(args.alnfile)
os.chdir(args.out_dir)
print("################################")
print("Blocks_file after chdir",
os.path.abspath(u.relative_to(__file__, './../building_blocks')))
# Read parameters (needed to build models from internal coordinates)
env.libs.topology.read('${LIB}/top_heav.lib')
env.libs.parameters.read('${LIB}/par.lib')
env.io.atom_files_directory = [
'.', '..', 'building_blocks',
os.path.abspath(u.relative_to(__file__, './../../building_blocks')),
os.path.abspath(u.relative_to(__file__, './../building_blocks'))
] #where to read atom files
env.edat.dynamic_sphere = True
env.edat.dynamic_lennard = False
env.edat.dynamic_coulomb = True
env.edat.relative_dielectric = 80
def test_find_pair():
json = u.relative_to(__file__, 'data/data.json')
d = u.load_json_data(json)
p1, p2, pdb = u.find_pair('APHshE', d.segments)
assert p1 == d.segments[4]['id'] - 1
def test_relative_to():
"""Test file name handling"""
import os
aln_file = u.relative_to(__file__, 'data/test-aln.ali')
#this file must exist in this relative path (since we put it there)
assert os.path.isfile(aln_file)
log.verbose() # request verbose output
if args.out_dir is None:
args.out_dir=d.name + u.id_generator()
if not os.path.exists(args.out_dir):
os.makedirs(args.out_dir)
#convert to absolute path before chdir
args.alnfile = os.path.abspath(args.alnfile)
os.chdir(args.out_dir)
print("################################")
print("Blocks_file after chdir", os.path.abspath(u.relative_to(__file__,'./../building_blocks')))
# Read parameters (needed to build models from internal coordinates)
env.libs.topology.read('${LIB}/top_heav.lib')
env.libs.parameters.read('${LIB}/par.lib')
env.io.atom_files_directory = ['.','..','building_blocks',
os.path.abspath(u.relative_to(__file__,'./../building_blocks'))] #where to read atom files
env.edat.dynamic_sphere = True
md_opt_dict = \
{'very_fast' : refine.very_fast,
'fast' : refine.fast,
'slow' : refine.slow,
'very_slow' : refine.very_slow,
def test_load_vfaces():
"""Tests loding of ply files. Python package plyfile must be installed."""
assert load_vfaces( u.relative_to(__file__, 'data/01_tetrahedron.ply'))==\
[[0, 2, 1], [0, 1, 3], [0, 3, 2], [1, 2, 3]], "Make sure plyfile is installed-"
import cocopod.utils as u
import os
from modeller import *
if __name__ == "__main__":
parser = argparse.ArgumentParser(__doc__,
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-j', '--json', help="json file name", default='data.json')
parser.add_argument('-aln', '--alignment', help="alignment file name", default='alignment-file.ali')
parser.add_argument('-p', '--path', help="path to template pdb files", default=None)
args = parser.parse_args()
if args.path is None:
#the default path should be raltive to the scripts directroy
args.path = u.relative_to(__file__,'../building_blocks')
d = u.load_json_data(args.json) #read json file
aln_str = d.entire_sequence
with open(args.alignment, 'w') as f1:
for pair in d.pairs: #go through all CC pairs
pair_1_id, pair_2_id, pdbname = u.find_pair(pair['pair'][0], d.segments)
pair_name = d.segments[pair_1_id].name + "_" + d.segments[pair_2_id].name
md_obj = md.load(os.path.join(args.path, pdbname))
topology = md_obj.topology #read topology
position = md_obj.xyz #and position from pdb file
pair_1_seq = u.mdtraj_to_fasta(topology,0)
