class Pdb2xyzr(CmdTool):
"""A pdb to xyzr format converter based on OpenBabel."""
args = [_("pdb_file", type="file", ext="pdb")]
out = [
_("pdb_prep_file", file="{pdb_file.stem}_prep.pdb"),
_("xyzr_file", file="{pdb_file.stem}.xyzr")
]
def _init(self, *args, **kwargs):
self.cmd = [
BABEL_CMD, '-i', 'pdb', self.pdb_prep_file, '-o', 'msms',
self.xyzr_file
]
self.output_files = [self.pdb_prep_file, self.xyzr_file]
def _pre_exec(self):
shutil.copy(self.pdb_file, self.pdb_prep_file)
def _post_exec(self):
if os.path.getsize(self.xyzr_file) == 0:
utils.path.remove(self.xyzr_file)
else:
xyz_file = utils.path.mod(self.xyzr_file, ext="xyz")
with open(self.xyzr_file, "r") as fp:
lines = fp.readlines()
with open(xyz_file, "w") as fp_out:
fp_out.write("%i\ncomment\n" % len(lines))
for d in lines:
ds = d.strip().split()
if not len(ds):
continue
l = "F\t%0.3f\t%0.3f\t%0.3f\n" % (float(
ds[0]), float(ds[1]), float(ds[2]))
fp_out.write(l)
class SpiderDeleteBackbone (Spider):
args = [
_( "map_file", type="file", ext="cpv" ),
_( "pdb_file", type="file", ext="pdb" ),
_( "pixelsize", type="float", range=[0, 10] )
]
out = [
_( "edited_pdb_file", file="nobb.pdb" ),
_( "delete_map_file", file="deletebb.cpv" )
]
script_tmpl = "delete_backbone.spi"
def _init( self, *args, **kwargs ):
super(SpiderDeleteBackbone, self)._init( "__tmpl__" )
def _pre_exec( self ):
backbone = ( ' N ',' C ', ' CA ',' O ' )
npdb=NumPdb( self.pdb_file )
back=npdb.sele(atomname=backbone)
npdb.copy(sele=back).write('nobb.pdb')
self._make_script_file(
map_name=self.relpath(self.map_file, no_ext=True) ,
pixelsize=self.pixelsize,
pdb_file='nobb.pdb'
)
class SplitPdbSSE (PyTool) :
args = [
_( "pdb_file", type="dir" )
]
out = [
_( "pieces_dir", dir="pieces" )
]
def func( self ):
npdb = numpdb.NumPdb( self.pdb_file, {
"phi_psi": False,
"sstruc": True,
"backbone_only": False,
"protein_only": False,
"detect_incomplete": False,
"configuration": False,
"info": False
})
for i, numa in enumerate( npdb.iter_sstruc() ):
print numa["chain"][0], numa["resno"].min(), numa["resno"].max()
print numa.sequence()
values_dic ={}
values_dic[1]=numa['resno'][0]
values_dic[2]=numa['resno'][-1]
values_dic[3]=numa.sequence()
values_dic[4]=numa['chain'][0]
if not os.path.exists(self.pieces_dir):
os.makedirs(self.pieces_dir)
file_name=os.path.join(self.pieces_dir, "%s_%s_%i-%i.%s" % (self.pdb_file[-8:-4],numa['chain'][0],numa['resno'][0],numa['resno'][-1],'pdb'))
file_namej=os.path.join(self.pieces_dir, "%s_%s_%i-%i.%s" % (self.pdb_file[-8:-4],numa['chain'][0],numa['resno'][0],numa['resno'][-1],'json'))
numa.write(file_name)
with open(file_namej, "w" ) as fp:
json.dump( values_dic,fp, indent=4 )
class SpiderCropMap ( Spider ):
args = [
_( "map_file", type="file", ext="cpv" ),
_( "pdb_file", type="file", ext="pdb" ),
_( "pixelsize", type="float", range=[1, 10], fixed=True )
]
out = [
_( "box_file", file="ergebnisse.cpv" ),
_( "box_map_file", file="boxil.cpv" )
]
script_tmpl = "crop2.spi"
def _init( self, *args, **kwargs ):
super(SpiderCropMap, self)._init( "__tmpl__" )
def _pre_exec (self):
npdb = NumPdb( self.pdb_file )
psf=1/self.pixelsize
schrumpf=npdb['xyz']*psf
#te=
ma=np.amax(schrumpf, axis=0)
mi=np.amin(schrumpf,axis=0)
middle=[(mi[0]+ma[0])/2,(mi[1]+ma[1])/2,(mi[2]+ma[2])/2]
abstand=round(((mi[0]-ma[0])**2+(mi[1]-ma[1])**2+(mi[2]-ma[2])**2)**0.5,0)
print ma,mi,middle,abstand
self._make_script_file(
x1=middle[0],
y1=middle[1],
z1=middle[2],
map_name=self.relpath(self.map_file, no_ext=True),
abstand=abstand,
ps=self.pixelsize,
)
class OpmList(PyTool):
args = [
_("class_id", type="str"),
]
out = [_("list_file", file="opm_list_class_{class_id}.json")]
def func(self):
list_record = opm_list(self.class_id)
ListIO(self.list_file).write(list_record)
class LoopRotamerOptimize ( PyTool ):
args = [
_("pdb_file", type="file"),
_("result_direc",type="str"),
_("residue_1",type="int"),
_("residue_2",type="int")
]
out=[
_( "verybestrotamers", file="verybestrotamers.pdb" )
]
# clashes fuer das ganze Protein bestimmen
def func (self):
npdb=NumPdb( self.pdb_file )
clashes,a=find_all_clashes(npdb)
gtree=get_tree(npdb['xyz'])
lclashes=[]
print clashes
resi=range(self.residue_1,self.residue_2)
print resi
for i in clashes:
print i[0], i[1]
if (i[0] or i[1]) in resi:
lclashes.append(i)
else:
continue
for x in lclashes:
print x
as1=x[0]
as2=x[1]
resname100=npdb.get('resname',resno=as1)[0]
resname101=npdb.get('resname',resno=as2)[0]
# #print resname100, resname101, i
if (resname100 and resname101) not in ('ALA','GLY'):
chain100=npdb.get('chain',resno=as1)[0]
chain101=npdb.get('chain',resno=as2)[0]
#print resname101
resno1=get_rotno(resname100)
resno2=get_rotno(resname101)
if resno1 >= resno2 :
# #print "anzahl rota" ,resno1,resno2
sele={'resno':as1}
atom_no= npdb.index(**sele)
# #erster clashpartner
rotadir="%s_%s_%i" % (chain100,resname100,as1)
ccsortpath=os.path.join(self.result_direc,rotadir)
ccsort="%s/%s" % (ccsortpath,'ccsort.cpv')
else:
sele={'resno':as2}
atom_no= npdb.index(**sele)
rotadir="%s_%s_%i" % (chain101,resname101,as2)
ccsortpath=os.path.join(self.result_direc,rotadir)
ccsort="%s/%s" % (ccsortpath,'ccsort.cpv')
class MakeAllRotameres( PyTool ):
args = [
_( "pdb_input", type="file", ext="pdb" ),
_( "chain|ch", type="str" ),
_( "resno|r", type="int" ),
_( "zfill", type="int", range=[0, 8], default=0 )
]
#out = [
# _( "rotamere_file", file="{pdb_input.stem}.pdb" )
#]
def func( self, *args, **kwargs ):
make_all_rotameres( self.pdb_input, self.chain, self.resno ,self.zfill, self.output_dir)
class HBexplore(CmdTool, ProviMixin):
"""A wrapper around the 'hbexplore' programm."""
args = [
_("pdb_file", type="file", ext="pdb"),
_("DAmax", type="float", default=3.9),
_("HAmax", type="float", default=2.5),
_("DHAmin", type="int", default=90),
_("HAA1_DAA1min", type="int", default=90),
_("HAhybmax", type="int", default=60),
_("waterAsDonorAcceptor", type="int", default=1),
_("c_hAsDonor", type="int", default=2),
]
out = [
_("params_file", file="{pdb_file.stem}_hbx.params"),
_("hbx_file", file="{pdb_file.basename}_hbx.anal"),
]
tmpl_dir = TMPL_DIR
provi_tmpl = "hbexplore.provi"
def _init(self, *args, **kwargs):
self.cmd = [HBEXPLORE_CMD]
self.cmd_input = self.params_file
self.no_cmd = False
def _pre_exec(self):
with open(self.params_file, "w") as fp:
fp.write("\n".join([
self.relpath(self.pdb_file),
".", # rel output dir
"n", # use_default_params
str(self.DAmax),
str(self.HAmax),
str(self.DHAmin),
str(self.HAA1_DAA1min),
str(self.HAhybmax),
str(self.waterAsDonorAcceptor),
str(self.c_hAsDonor),
"", # separate_tables_and_distributions,
"0", # additional_connectivity_files,
"", # potential_hydrogen_bond_dataset,
"n", # search_for_specific_hbonds
]) + "\n\n")
def _post_exec(self):
provi.prep_hbexplore(self.hbx_file, self.pdb_file)
self._make_provi_file(pdb_file=self.relpath(self.pdb_file),
hbonds_file=self.relpath(self.hbx_file +
".bonds"))
@memoize_m
def get_hbonds(self):
return parse_hbx_output(self.hbx_file)
class ListJoin( PyTool ):
args = [
_( "list", type="file", ext="json", nargs="+" ),
_( "list_name|ln", type="str", default=None )
]
out = [
_( "joined_list", file="joined_list.json" )
]
def func( self ):
joined_list = list_join(
*map( lambda x: ListIO( x ).read(), self.list ),
name=self.list_name
)
ListIO( self.joined_list ).write( joined_list )
class LoopSidechainCorrelation (PyTool):
args = [
_( "map_file", type="file", ext="cpv" ),
_( "pdb_file", type="file", ext="pdb" ),
_( "pixelsize", type="float", range=[0, 10] ),
_( "resolution", type="float", range=[0, 10] ),
]
out = [
_( "sidechain_dir", dir="sidechains" )
]
tmpl_dir = TMPL_DIR
def _init( self, *args, **kwargs ):
self.delete_backbone= SpiderDeleteBackbone(
self.map_file,
self.pdb_file,
self.pixelsize,
**copy_dict( kwargs, run=False )
)
def func( self ):
self.delete_backbone()
npdb=NumPdb( self.pdb_file )
for i, numa in enumerate( npdb.iter_resno() ):
sele={'resno':i+1}
resname1=numa.get('resname') [0]
resno1=numa.get('resno') [0]
chain1=numa.get('chain') [0]
dirg="%s_%s_%i" %(chain1,resname1,resno1)
print resname1, resno1, chain1
if numa.get('resname') [0] not in ('ALA', 'GLY'):
if resname1 in ('SER','CYS','PRO','ASP','THR','ASN','VAL','GLU','GLN'):
SpiderSidechainCorrelation(self.map_file, self.pdb_file, self.pixelsize,self.resolution, resno1, chain1,output_dir=self.subdir(dirg))
else:
SpiderSidechainCorrelation('deletebb.cpv', self.pdb_file, self.pixelsize,self.resolution, resno1, chain1,output_dir=self.subdir(dirg))
aaname="%s.%s" %(dirg,'pdb')
print aaname
aa=npdb.sele(resname=resname1,resno=resno1)
dire="%s/%s" %(dirg,aaname)
npdb.copy(sele=aa).write(dire)
OriSidechainCorrel('deletebb.cpv',dire,self.pixelsize,self.resolution,resno1,chain1,output_dir=self.subdir(dirg))
else:
aaname="%s.%s" %(dirg,'pdb')
print aaname
aa=npdb.sele(resname=resname1,resno=resno1)
dire="%s/%s" %(dirg,aaname)
if not os.path.exists(self.subdir(dirg)): os.makedirs(self.subdir(dirg))
npdb.copy(sele=aa).write(dire)
class Sstruc(PyTool, RecordsMixin, ParallelMixin):
args = [
_("pdb_input", type="file", ext="pdb"),
_("pdb_id", type="text", default=None)
]
RecordsClass = SstrucDbRecord
def _init(self, *args, **kwargs):
self._init_records(self.pdb_input, **kwargs)
self._init_parallel(self.pdb_input, **kwargs)
def func(self):
self.records = BuildSstrucDbRecords(self.pdb_input).get()
self.write()
class Capture(PyTool, RecordsMixin, ParallelMixin, ProviMixin):
""" CaPTURE web service wrapper (http://capture.caltech.edu/).
"""
args = [
_("pdb_input", type="file", ext="pdb"),
_("parse_only", type="bool", default=False),
_("occupancy_one", type="bool", default=False),
]
out = [
_("capture_file", file="CaPTURE_{pdb_input.stem}.txt"),
]
RecordsClass = CaptureRecord
tmpl_dir = TMPL_DIR
provi_tmpl = "capture.provi"
def _init(self, *args, **kwargs):
self.pdb_id = utils.path.stem(self.pdb_input)
self._init_records(None, **kwargs)
self._init_parallel(self.pdb_input, **kwargs)
def func(self):
if not self.parse_only:
capture_web(self.pdb_input, self.capture_file)
self.records = [
CaptureRecord(self.pdb_id, *x)
for x in parse_capture(self.capture_file)
]
self.write()
def _pre_exec(self):
if self.occupancy_one:
occ_file = "occupancy_one.pdb"
npdb = NumPdb(self.pdb_input)
npdb['occupancy'] = 1.0
npdb.write(occ_file)
self.pdb_input = self.outpath(occ_file)
def _post_exec(self):
script = []
for r in self.records:
p = (r.es, r.chain_cation, r.resno_cation, r.chain_pi, r.resno_pi)
s = ("var colr = color( 'rwb', -5, 5, %f ); "
"select { "
" (chain='%s' and resno=%i) or "
" (chain='%s' and resno=%i) "
"}; "
"wireframe 0.2; color @colr; " % p)
script.append(s)
self._make_provi_file(pdb_file=self.relpath(self.pdb_input),
script=" ".join(script))
class SstrucInfo(PyTool):
args = [_("pdb_file", type="file", ext="pdb"), _("sele", type="sele")]
def _init(self, *args, **kwargs):
pass
def func(self):
npdb = numpdb.NumPdb(self.pdb_file)
self.sele["atomname"] = "CA"
numa = npdb.copy(**self.sele)
sstruc_order = []
for k, g in itertools.groupby(numa['sstruc']):
n = len(list(g))
sstruc_order.append((k, n))
print k, n
class PdbHetDictionary( PyTool ):
"""
Tool to extract the names of (non-standard) amino acids from
ftp://ftp.rcsb.org/pub/pdb/data/monomers/het_dictionary.txt
"""
args = [
_( "het_file", type="file", ext="txt", help="hetero dictionary" )
]
out = [
_( "aa_file", file="aa.json" )
]
def func( self ):
aminoacid_list = parse_het_dictionary( self.het_file )
with open( self.aa_file, "w" ) as fp:
json.dump( aminoacid_list, fp )
class Opm(OpmMixin, PyTool, ProviMixin):
"""A tool to access the OPM database pdb files"""
args = [
_("pdb_id", type="str"),
]
out = [
_("opm_file", file="{pdb_id}_opm.pdb"),
_("mplane_file", file="{pdb_id}.mplane"),
_("processed_file", file="{pdb_id}_proc.pdb"),
_("info_file", file="{pdb_id}_info.json", optional=True),
]
def func(self):
with open(self.opm_file, "w") as fp:
fp.write(opm(self.pdb_id))
class SpiderCrosscorrelation( Spider ):
args = [
_( "map_file", type="file", ext="cpv" ),
_( "box_map_file", type="file", ext="cpv" ),
_( "box_file", type="file", ext="cpv" ),
_( "loop_file", type="file", ext="pdb" ),
_( "linkerinfo", type="file", ext="txt" ),
_( "max_loops", type="int", range=[0, 200], default=100 )
]
out = [
_( "loop_dir", dir="loops" ),
_( "crosscorrel_file", file="crosscorrelation.cpv" ),
_( "crosscorrel_json", file="crosscorrelation.json" )
]
script_tmpl = "crosscorrelation.spi"
def _init( self, *args, **kwargs ):
if not self.max_loops:
self.max_loops = False
super(SpiderCrosscorrelation, self)._init( "__tmpl__" )
def _pre_exec( self ):
self._split_loop_file()
self._make_script_file(
map_name=self.relpath( self.map_file, no_ext=True ),
box_map_name=self.relpath( self.box_map_file, no_ext=True ),
box_name=self.relpath( self.box_file, no_ext=True ),
loop_dir=self.relpath( self.loop_dir ) + os.sep,
max_loops=self.max_loops or 999
)
def _post_exec( self ):
self._make_crosscorrel_json( compact=True )
def _split_loop_file( self ):
PdbSplit(
self.loop_file, self.linkerinfo,
output_dir=self.loop_dir, backbone_only=True,
max_models=self.max_loops, resno_ignore=[ 1000, 2000 ], zfill=3
)
def _make_crosscorrel_json( self, compact=False ):
crosscorrel_dict = {}
with open( self.crosscorrel_file, "r" ) as fp:
for line in fp:
d = line.split()
if len(d) == 3:
crosscorrel_dict[ int(d[0]) ] = float( d[2] )
with open( self.crosscorrel_json, "w" ) as fp:
if compact:
json.dump( crosscorrel_dict, fp, separators=(',', ':') )
else:
json.dump( crosscorrel_dict, fp, indent=4 )
class JoinSplitted( PyTool ):
args = [
_( "splitted_ids", type="str" ),
_( "clear", type="bool", default=False,
help="deletes the downloaded splited pdbs")
]
out = [
_( "all_joined", file="all_joined.pdb" )
]
def _init( self, *args, **kwargs ):
self.splitted_files=self.splitted_ids.split(',')
def func( self ):
self.joined = join_splitted( self.splitted_files, self.output_dir, self.clear )
def _post_exec( self ):
with open(self.all_joined, 'w') as fp:
fp.write(self.joined)
class MpstrucDownload(PyTool):
"""A tool to download the MPstruc database"""
out = [_("mpstruc_xml", file="mpstruc.xml")]
def func(self):
with open(self.mpstruc_xml, "w") as fp:
fp.write(mpstruc_download())
class MpstrucList(PyTool):
args = []
out = [_("list_file", file="mpstruc_list.json")]
def func(self):
list_record = mpstruc_list()
ListIO(self.list_file).write(list_record)
class SpiderBox( Spider ):
args = [
_( "mrc_file", type="file", ext="mrc" ),
_( "map_file", type="file", ext="cpv" ),
_( "pdb_file", type="file", ext="pdb" ),
_( "res1", type="sele", help="resno:chain, i.e. 10:A" ),
_( "res2", type="sele" ),
_( "length", type="int", range=[1, 30] ),
#_( "pixelsize", type="slider", range=[1, 10], fixed=True ),
_( "resolution", type="float", range=[1, 10],
help="of the map_file" )
]
out = [
_( "var_file", file="variables.cpv" ),
_( "box_file", file="ergebnisse.cpv" ),
_( "box_map_file", file="boxil.cpv" )
]
script_tmpl = "box.spi"
def _init( self, *args, **kwargs ):
super(SpiderBox, self)._init( "__tmpl__" )
def _pre_exec( self ):
boxsize=getMrc(self.mrc_file,'nx' )
size=getMrc(self.mrc_file,'xlen' )
pixelsize=(size/boxsize)
coords1, coords2 = self._get_coords(
self.pdb_file, self.res1, self.res2
)
self._make_variables_file(
coords1, coords2, self.length, pixelsize, self.resolution
)
self._make_script_file(
map_name=self.relpath( self.map_file, no_ext=True ),
var_name=self.relpath( self.var_file, no_ext=True )
)
def _get_coords( self, pdb_file, res1, res2 ):
npdb = NumPdb( pdb_file )
return npdb.center( **res1 ), npdb.center( **res2 )
def _make_variables_file( self, coords1, coords2, length,
pixelsize, resolution ):
variables = "1 9 %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f %i %4.2f %4.2f" % (
coords1[0], coords1[1], coords1[2],
coords2[0], coords2[1], coords2[2],
length, pixelsize, resolution
)
with open( self.var_file, "w" ) as fp:
fp.write( variables )
class PdbAssembly( PyTool ):
args = [
_( "pdb_id", type="str",
help="pdb id" )
]
out = [
_( "assembly_file", file="assembly.pdb" )
]
def func( self ):
try:
data = pdb_assembly( self.pdb_id )
except:
# if assembly download fails there is probably no assembly
# so download the standard pdb file
data = pdb_download( self.pdb_id )
with open( self.assembly_file, "w" ) as fp:
fp.write( data )
class SpiderSidechainCorrelation ( Spider ):
args = [
_( "map_file", type="file", ext="cpv" ),
_( "pdb_file", type="file", ext="pdb" ),
_( "pixelsize", type="float", range=[0, 10] ),
_( "resolution", type="float", range=[0, 10] ),
_( "residue", type="int", range=[0, 999] ),
_( "chain", type="str" )
]
out = [
_( "sidechain_dir", dir="rotamere" ),
_( "sccrosscorrel_file", file="sccrosscorrelation.cpv" ),
_( "crosscorrel_json", file="crosscorrelation.json" )
]
script_tmpl = "sidechaincc.spi"
def _init( self, *args, **kwargs ):
super(SpiderSidechainCorrelation, self)._init( "__tmpl__" )
def _pre_exec( self ):
npdb=NumPdb( self.pdb_file )
sele={"resno": self.residue, "chain": self.chain}
resname1=npdb.get('resname', **sele)[0]
num_rota=get_rotno(resname1)
coords=self._get_ca(self.pdb_file,self.chain, self.residue)
print "huh" ,coords [0] [0]
x_ca= coords[0] [0]
y_ca=coords [0][1]
z_ca=coords [0] [2]
self._make_script_file(
resolution=self.resolution,
pixelsize=self.pixelsize,
map_name=self.relpath( self.map_file, no_ext=True ),
x_ca=x_ca ,
y_ca=y_ca,
z_ca=z_ca,
cc_dir=self.relpath( self.sidechain_dir ) + os.sep,
num_rota=num_rota,
resname1=self.relpath (self.sidechain_dir)+ os.sep+resname1,
residue=self.residue
)
MakeAllRotameres(self.pdb_file, self.chain,self.residue,zfill=2,output_dir=self.sidechain_dir)
def _get_ca (self,pdb_file,chain, residue):
npdb=NumPdb( pdb_file )
sele1={"resno": self.residue, "chain": self.chain}
resname1=npdb.get('resname', **sele1)[0]
sele={"resno": residue, "chain": chain, "resname": resname1 ,"atomname":'CA'}
cacoord=npdb.get('xyz',**sele)
return cacoord
class PdbUnzip( PyTool ):
args = [
_( "pdb_archive", type="dir" )
]
def func( self ):
pdb_file_list = get_pdb_files( self.pdb_archive, pattern="ent.gz" )
for pdb_file in pdb_file_list:
unzip_pdb( pdb_file )
class PdbtmDownload( PyTool ):
"""A tool to download the Pdbtm database"""
out = [
_( "pdbtm_xml", file="pdbtm.xml" )
]
def func( self ):
with open( self.pdbtm_xml, "w" ) as fp:
fp.write( pdbtm_download() )
class OptimizeRotamer ( PyTool ):
args = [
_("result_direc",type="str")
]
out = [
_( "verybestrotamers", file="verybestrotamers.pdb" )
]
def _init( self , *args, **kwargs ):
self.bestbuild=BuildBest(self.result_direc)
def func (self):
self.bestbuild()
npdb=NumPdb( "bestrotamers.pdb" )
a=True
z=2
#while a==True:
clashes,a=find_all_clashes(npdb)
gtree=get_tree(npdb['xyz'])
print clashes
for i in clashes:
localresi=[]
#hole CA atom vom ersten clashpartner
r=npdb.sele(resno=i[0],atomname='CA')
p=npdb.get('xyz',sele=r)
#indices im 6 A umkreis um den clash
l=gtree.query_ball_point(p,6)
print l[0]
#aus den indices eine liste mit residuname und nummer machen
for x in l[0]:
a=npdb.get('resname')[x]
b=npdb.get('resno')[x]
c=npdb.get('chain')[x]
localresi.append([b,a,c])
localresi=sorted(localresi)
localresi=list(localresi for localresi,_ in itertools.groupby(localresi))
#print localresi
for index,i in enumerate (localresi):
if i[1] not in ('ALA','GLY'):
rotadir="%s_%s_%i" % (i[2],i[1],i[0])
ccsortpath=os.path.join(self.result_direc,rotadir)
ccsort="%s/%s" % (ccsortpath,'ccsort.cpv')
print ccsortpath
break
class MrcHeaderPrinter( PyTool ):
args = [
_( "mrc_file", type="file", ext="mrc" )
]
def func( self, *args, **kwargs ):
header = mrc_header( self.mrc_file )
for name, value in zip(header._fields, header):
print "%20s\t%s" % ( name, value )
class MppdStats(PyTool):
args = [_("mppd_file", type="file", ext="json")]
def _init(self, *args, **kwargs):
pass
def func(self):
records = JsonBackend(self.mppd_file, MppdRecord)
print len(records)
class VoronoiaStats(PyTool):
args = [_("voronoia_file", type="file", ext="json")]
def _init(self, *args, **kwargs):
pass
def func(self):
records = JsonBackend(self.voronoia_file, VoronoiaRecord)
print len(records)
class PdbtmInfo( PyTool ):
"""A tool to get infos from the PDBTM database"""
args = [
_( "pdb_id", type="str" ),
]
out = [
_( "info_file", file="pdbtm_info_{pdb_id}.json" )
]
def _init( self, *args, **kwargs ):
pass
def func( self ):
self.info = pdbtm_info( self.pdb_id )
with open( self.info_file, "w" ) as fp:
json.dump( self.info, fp, indent=4 )
def get_info( self ):
if not hasattr( self, "info" ):
with open( self.info_file, "r" ) as fp:
self.info = json.read( fp )
return self.info
class PdbtmList( PyTool ):
args = [
]
out = [
_( "list_file", file="pdbtm_list.json" )
]
def func( self ):
list_record = pdbtm_list()
ListIO( self.list_file ).write( list_record )
