def test_ignore_known_binary_files(self):
fs = Mock([
("stat", ["."], {}, trim.StatResult(isDir=True)),
("listdir", ["."], {}, ["image.png", "somescript.pyc"]),
])
outputStream = StringIO()
t = Trim(fs=fs, stdout=outputStream)
t.process(".")
output = outputStream.getvalue()
self.assertTrue(fs.everything_called())
self.assertEqual(output, "")
def test_ignore_dotfiles(self):
fs = Mock([
("stat", ["."], {}, trim.StatResult(isDir=True)),
("listdir", ["."], {}, [".hello.txt"]),
])
outputStream = StringIO()
t = Trim(fs=fs, stdout=outputStream)
t.process(".")
output = outputStream.getvalue()
self.assertTrue(fs.everything_called())
self.assertEqual(output, "")
def test_ignore_too_big_files(self):
fs = Mock([
("stat", ["."], {}, trim.StatResult(isDir=True)),
("listdir", ["."], {}, ["somebigfile"]),
("stat", ["./somebigfile"], {}, trim.StatResult(size=1001001, isFile=True)),
])
outputStream = StringIO()
t = Trim(fs=fs, stdout=outputStream)
t.process(".")
output = outputStream.getvalue()
self.assertTrue(fs.everything_called())
self.assertEqual(output, "")
def test_trim_file_dry_run(self):
fs = Mock([
("stat", ["."], {}, trim.StatResult(isDir=True)),
("listdir", ["."], {}, ["hello.txt"]),
("stat", ["./hello.txt"], {}, trim.StatResult(size=7, isFile=True)),
("get_contents", ["./hello.txt"], {}, "Hello \n"),
])
outputStream = StringIO()
t = Trim(fs=fs, stdout=outputStream, dryRun=True)
t.process(".")
output = outputStream.getvalue()
self.assertTrue(fs.everything_called(), fs)
self.assertEqual(output, "./hello.txt\n")
def initial_trim_case(self):
""" Passes the :parameter:`initial_velocity` to the :class:`Trim` to obtain state variables at trim condition
:return: Trim object containing all state-variables at the desired trim condition
:rtype: Trim
"""
return Trim(self.initial_velocity)
def plot_derivatives():
# TODO Finish plotting these derivatives if necessary for the report
pbar = ProgressBar('Obtaining Stability Derivatives for Entire Flight Envelope')
velocities = np.linspace(0, 75, 20)
x_u = []
x_w = []
for i, v in enumerate(velocities):
trim_case = Trim(v)
derivatives = StabilityDerivatives(u=trim_case.u, w=trim_case.w, q=0,
theta_f=trim_case.fuselage_tilt,
collective_pitch=trim_case.collective_pitch,
longitudinal_cyclic=trim_case.longitudinal_cyclic)
x_u.append(derivatives.u_derivatives[0])
x_w.append(derivatives.u_derivatives[1])
pbar.update_loop(i, len(velocities)-1, 'V = %1.2f [m/s]' % v)
plt.plot(velocities, x_u)
plt.plot(velocities, x_w)
plt.show()
return 'Figure Plotted and Saved'
def computeProcess(param):
fastqc, trim, bsmap, mcall, bedtools = Fastqc(), Trim(), Bsmap(), Mcall(
), Bedtools()
ProcessObject = [fastqc, trim, bsmap, mcall, bedtools]
for obj in ProcessObject:
status, word = obj.check()
#if not status:
# raise Exception(word)
#check all software have been installed successfully.
for obj in ProcessObject[:-1]:
obj.setpath('./')
bsmap.setparam(param)
mcall.setparam(param)
name = param['name']
resultfilename = {}
if param['qc']:
name, qcresult = computeQC(name, fastqc, {})
resultfilename['qc'] = qcresult
os.system('mkdir RESULT/qc')
os.system('cp Fastqc/*.html RESULT/qc')
if param['trim']:
name, trimresult = computeTrim(name, trim, {})
resultfilename['trim'] = trimresult
name, bsmapresult = computeBsmap(name, bsmap, param)
resultfilename['bsmap'] = bsmapresult
print(resultfilename)
#resultfilename={}
#resultfilename['trim']=
#resultfilename['bsmap']
#name=['BAM_FILE/6P1_notrim_val_1_val_1_combine.bam']
name, mcallresult = computeMcall(name, mcall, param)
resultfilename['mcall'] = mcallresult
meth_cpg_bed_name = name
'''
All computing job is done here. Plotting is behind.
Table:
Filename, Label, trim ratio(TrimOutputExtractor),input reads,mapped reads, unique mapped reads,
clipped reads, unique clipped reads, all mapped reads, unique all, mapping ratio, unique mapping ratio
Plots:
1. Extract trim ratio from trim report files. Generate a bar plot
2. Extract bsmap mapping ratio
3.
'''
originalfilename = param['name']
filelabel = param['label']
marker = ['Filename', 'Label']
marker.append('QC')
if param['qc']:
qcresult = []
prepath = "qc/"
for q in resultfilename['qc']:
if len(q) == 1:
qcresult.append('<a href="' + prepath + q[0] + '">QC' + '</a>')
else:
qcresult.append('<a href="' + prepath + q[0] + '">QC1' +
'</a>,' + '<a href="' + prepath + q[1] +
'">QC2' + '</a>')
else:
qcresult = ["/" for i in range(len(originalfilename))]
marker.append('Trim')
if param['trim']:
trimresult = TrimOutputExtractor(
resultfilename['trim']) #,param['clip'])
else:
trimresult = ["/" for i in range(len(originalfilename))]
'''
Result from BsmapResult:
[[total reads,mapped reads,uniquely mapped reads, clipped reads, unique clipped reads,
all mapped reads, all uniquely mapped reads, mapping ratio, uniquely mapping ratio],...]
'''
marker.extend(['Input reads','mapped reads','uniquely mapped reads','clipped reads', \
'uniquely clipped reads','all mapped reads','all uniquely mapped reads',\
'mapping ratio','uniquely mapping ratio'])
bsmapresult = BsmapResult(
resultfilename['bsmap'],
param['clip']) #All contents required by the last extend
sample = 0
datatable = [marker]
#print(trimresult)
for orin in originalfilename:
l = filelabel[sample]
br = bsmapresult[sample]
temp = []
filenum = 0
if len(orin) == 1:
nn = orin[0]
else:
nn = orin[0] + ',' + orin[1]
temp.extend([nn, l])
#if param['qc']:
temp.append(qcresult[filenum])
#if param['trim']:
trim_s = trimresult[sample]
if trim_s == "/" or len(trim_s) == 1:
temp.append(trimresult[sample][0])
else:
temp.append(trimresult[sample][0] + ',' + trimresult[sample][1])
filenum = filenum + 1
temp.extend(br)
sample = sample + 1
datatable.append(temp)
datatableprint = list(
map(
lambda x:
((''.join(list(map(lambda y: str(y) + '\t', x)))).strip() + '\n'),
datatable))
with open('RESULT/datatable.txt', 'w') as f:
f.writelines(datatableprint)
'''
Table generated as RESULT/datatable.txt
'''
#print(filelabel)
if param['genome'] != None and len(filelabel) > 1:
bedtools.setparam(param)
bedtools.makewindow()
shortnames = list(map(lambda x: x + '.short.bed', meth_cpg_bed_name))
intersectnames = bedtools.intersect(name)
methdic = union(intersectnames)
columns = ['chrom', 'start', 'end']
#print(methdic)
methdata = list(map(lambda x: x.split() + methdic[x], methdic))
#columns.extend(list(map(lambda x:'F'+str(x),list(range(1,len(methdata[0])-2)))))
columns.extend(filelabel)
#print(methdata)
#print(columns)
df = DataFrame(methdata, columns=columns)
point_cluster(df, 'RESULT/point_cluster.png')
heatmap(df, 'RESULT/heatmap.png')
abspath = os.path.abspath(__file__)
pos = abspath.find('computeProcess')
abspath = abspath[:pos]
os.system('cp ' + abspath + 'result.html RESULT/')
os.system('cp -r ' + abspath + 'lib RESULT/')
def classFactory(iface): # pylint: disable=invalid-name
#
from trim import Trim
return Trim(iface)
