import sys
import os
from parameter import Parameter
p = Parameter("stream.reads.")
reads_1 = p._("1")
reads_2 = p._("2")
os.system("paste -d '\n' {0} {1}".format(reads_1, reads_2))
import sys
from parameter import Parameter
from common import Dictionary
p = Parameter("release.")
release = p._("path")
dic = Dictionary(p._("dictionary"))
for line in sys.stdin:
entry = line.strip().split("\t")
id = int(entry[0])
l = int(entry[1])
score = entry[2]
contig = dic._(id)
name = contig[0]
cls = contig[2]
print "{0}\t{1}\t{2}\t{3}\t{4}\t{5}".format(id, name, cls, contig[1], l,
score)
import os
from parameter import Parameter
p = Parameter()
# create dir tree
dir = p._('project.dir')
name = p._('project.wizard.create.name')
project_dir = dir + '/' + name
os.system('rm -rf {}'.format(project_dir))
os.system('mkdir {}'.format(project_dir))
os.system('mkdir {}/data'.format(project_dir))
os.system('mkdir {}/data/structure'.format(project_dir))
os.system('mkdir {}/data/structure/receptor'.format(project_dir))
os.system('mkdir {}/data/structure/ligand'.format(project_dir))
os.system('mkdir {}/docking'.format(project_dir))
os.system('mkdir {}/docking/receptor'.format(project_dir))
os.system('mkdir {}/docking/ligand'.format(project_dir))
os.system('mkdir {}/log'.format(project_dir))
os.system('mkdir {}/stage'.format(project_dir))
os.system('mkdir {}/report'.format(project_dir))
from parameter import Parameter
from ligand import Ligand
from receptor import Receptor
def line(id, ligand):
ids = [str(id)]
ligand.foreachId(lambda id: ids.append(str(id)))
return '\t'.join(ids)
p = Parameter()
ligand = Ligand(p._('project.ligand.db'))
receptor = Receptor(p._('project.receptor.db'))
receptor.foreachId(lambda id: print(line(id, ligand)))
ligand.close()
receptor.close()
import re
import glob
import ntpath
import os
from parameter import Parameter
from receptor import Receptor
from path import Path
p = Parameter()
pt = Path(p)
#locate tree
dir = p._('project.dir') + '/'
name = p._('project.wizard.create.name')
project_dir = dir + name
data_dir = project_dir + '/data/'
filename = '{}/stage/{}'.format(project_dir,
p._('project.wizard.load.receptor'))
# import ligands
molecule = Receptor(data_dir + p._('project.wizard.receptor.db'))
molecule.clear()
# import data
for id in open(filename):
id = id.strip('\n')
molecule.add(id)
molecule.commit()
for item in table.items():
id = item[0]
l = item[1][0]
data = item[1][1]
cls = item[1][2]
name = item[1][3]
score = feuler_score(l, data, mean, stdv)
table[id] = (l,score,cls,name)
p = Parameter("feuler.")
dict = Dictionary(p._("dictionary"))
max_len = 0
table = {}
for line in sys.stdin:
line = line.strip().split("\t")
if (len(line))>2:
contig = dict._(int(line[0]))
id = int(line[0])
name = contig[0]
cls = contig[2]
lref = int(line[1])
data = line[2]
from parameter import Parameter
p = Parameter("stream.contigs.")
for line in open(p._("source")):
print line.strip()
from parameter import Parameter
def to_binary(str, one):
bin = "".join(
map(lambda x: "{0}".format(int(string.find(one, x) > -1)), str))
rest = len(bin) % 4
if rest > 0:
return bin + "0000"[rest:]
else:
return bin
p = Parameter("encode.")
path = p._("dictionary")
one = p._("one")
# load dictionary
file = open(path)
code = {}
for line in file:
entry = line.split("\t")
code[entry[0]] = (entry[1], entry[2])
file.close()
for line in sys.stdin:
entry = line.split()
c = code[entry[0]]
print "{0} {1} {2}".format(c[1].strip(), c[0], to_binary(entry[1], one))
import sys
import string
from parameter import Parameter
def to_binary(str, one):
bin = "".join(
map(lambda x: "{0}".format(int(string.find(one, x) > -1)), str))
rest = len(bin) % 4
return bin + "0000"[rest:]
p = Parameter("encode.reads.")
one = p._("one")
for line in sys.stdin:
line = line.strip()
print to_binary(line, one)
import os
from parameter import Parameter
from ligand import Ligand
p = Parameter()
dir = p._('project.dir') + '/'
project_dir = dir + p._('project.wizard.create.name') + '/'
data_dir = project_dir + 'data/'
molecule = Ligand(data_dir + p._('project.wizard.ligand.db'))
columns = p._('project.wizard.ligand_report.columns')
molecule.foreachRecord(columns, lambda id, fields: print(id, fields, sep='\t'))
molecule.close()
import sys
from parameter import Parameter
from common import Dictionary
def reapr_score(l, data, width, mdh, k):
return data
p = Parameter("reapr.")
out_path = p._("out_path")
width = p.i("width")
mdh = p.i("mdh") # max differential height
k = p.i("k")
dict = Dictionary(p._("dictionary"))
max_len = 0
for line in sys.stdin:
line = line.strip().split("\t")
if (len(line)) > 2:
contig = dict._(int(line[0]))
id = line[0]
cls = contig[2]
lref = int(line[1])
ref = line[2]
max_len = max(lref, max_len)
print "{0}\t{1}\t{2}\t{3}".format(
id, cls, lref, reapr_score(lref, ref, width, mdh, k))
import os
from parameter import Parameter
from receptor import Receptor
p = Parameter()
dir = p._('project.dir') + '/'
project_dir = dir + p._('project.wizard.create.name')
data_dir = project_dir + '/data/'
molecule = Receptor(data_dir + p._('project.wizard.receptor.db'))
columns = p._('project.wizard.receptor_report.columns')
molecule.foreachRecord(columns, lambda id, fields: print(id, fields, sep='\t'))
molecule.close()
import os
from parameter import Parameter
from ligand import Ligand
p = Parameter()
#locate tree
dir = p._('project.dir')
name = p._('project.wizard.create.name')
project_dir = dir + '/' + name
data_dir = project_dir + '/data'
filename = '{}/stage/{}'.format(project_dir, p._('project.wizard.load.ligand'))
#import data
molecule = Ligand(data_dir + '/' + p._('project.wizard.ligand.db'))
molecule.clear()
for id in open(filename):
id = id.strip('\n')
molecule.add(id)
molecule.commit()
# download ligand structures
def save(id, s, format, dir):
filename = '{}/{}.{}'.format(dir, id, format)
with open(filename, 'w') as file:
file.write(s)
print(id)
import sys
import os
from pairdaemon import PairDaemon
from parameter import Parameter
from path import Path
from pair import Pair
process_name = 'docking'
p = Parameter()
pt = Path(p)
user = p._('user')
payload = p.i('daemon.sbatch.payload')
db = Pair(pt.receptordb, pt.liganddb)
class Matrix(PairDaemon):
def __init__(self):
PairDaemon.__init__(self,
user,
db,
pt,
payload,
process_name)
def score(self, pid, cid):
score_file = pt.pairdir(pid,cid) + '/scoring.log'
try:
with open(score_file) as file:
data = file.read().split('\n')[::-1]
from parameter import Parameter
from pair import Pair
p = Parameter()
root = p._('root')
dir = root + '/' + p._('project.wizard.name')
pair = Pair(dir + '/pair.db')
pair.foreach(
lambda pid, cid : print(pid, cid, sep = '\t')
)
pair.close()
dm = param[3]
dm.update(r, k, th)
def flush(dm):
print "saving ...\n"
dm.save()
def jump(current, limit):
return current + random.randint(1, limit)
p = Parameter("dsbuilder.")
path = p._("contigs_path")
sim_threshold = p.f("sim_threshold")
k = p.i("k")
css = p.i("contigs_sample_size")
rss = p.i("reads_sample_size")
rrj = p.i("reads_random_jump")
save_frequency = p.i("save_frequency")
out_path = p._("out_path")
dm = DataManager(path, out_path, css)
print "processing {0} contigs and {1} reads".format(css, rss)
#receive reads stream
count = 0
pos = 0
def ok(line):
field = re.split('\s+', line)
if field[0] == 'ANISOU':
return False
if field[0] in ['ATOM', 'HETATM']:
return field[2].upper() not in ['NA']
return True
def remove_noise(id, path, incl):
if id in incl:
content = open(path).read().strip('\n').split('\n')
newcontent = [s for s in content if ok(s)]
if len(content) != len(newcontent):
open(path, 'w').write('\n'.join(newcontent))
print(id)
p = Parameter()
pt = Path(p)
molecule = Receptor(pt.receptordb)
incl = p._('project.wizard.receptor_remove_noise.include').split(',')
molecule.foreachId(lambda id: remove_noise(id, pt.receptor(id), incl))
import os
from parameter import Parameter
from ligand import Ligand
from receptor import Receptor
from path import Path
def print_pairs(pid, ligand):
ligand.foreachId(lambda cid: print(pid, cid, sep='\t'))
p = Parameter()
pt = Path(p)
ligand = Ligand(pt.data + p._('project.wizard.ligand.db'))
receptor = Receptor(pt.data + p._('project.wizard.receptor.db'))
receptor.foreachId(lambda id: print_pairs(id, ligand))
ligand.close()
receptor.close()
import os
from parameter import Parameter
from path import Path
from ligand import Ligand
p = Parameter()
pt = Path(p)
#locate tree
dir = p._('project.dir')
name = p._('project.wizard.create.name')
project_dir = dir + '/' + name
data_dir = project_dir + '/data'
filename = '{}/stage/{}'.format(project_dir, p._('project.wizard.load.ligand'))
#import data
molecule = Ligand(pt.liganddb)
molecule.clear()
for id in open(filename):
id = id.strip('\n')
molecule.add(id)
molecule.commit()
# download ligand structures
def instage(id, pt):
return pt.filename('{}.pdb'.format(id), pt.stage, '*.pdb') != None
