def parse_args():
parser = argparse.ArgumentParser(description='Options for MVNet')
parser.add_argument('--log', type=str, default=None)
parser.add_argument('--val_batch_size', type=int, default=4)
parser.add_argument('--val_im_batch', type=int, default=4)
parser.add_argument('--loglevel', type=str, default='info')
parser.add_argument('--val_split_file',
type=str,
default='data/splits.json')
parser.add_argument('--prefetch_threads', type=int, default=2)
parser.add_argument('--sleep_time', type=int, default=15)
args = process_args(parser)
return args
def parse_args():
parser = argparse.ArgumentParser(description='Options for MVNet')
parser.add_argument('--log', type=str, default=None)
parser.add_argument('--test_batch_size', type=int, default=4)
parser.add_argument('--test_im_batch', type=int, default=4)
parser.add_argument('--eval_thresh', type=float, nargs='+', default=[0.4])
parser.add_argument('--ckpt', type=str, default=None)
parser.add_argument('--split', type=str, default='test')
parser.add_argument('--result_file', type=str, default=None)
parser.add_argument('--loglevel', type=str, default='info')
parser.add_argument(
'--test_split_file', type=str, default='data/splits.json')
parser.add_argument('--prefetch_threads', type=int, default=2)
args = process_args(parser)
return args
def main(): args = utils.process_args() distance = utils.distance_between(args['PICKUP'], args['DROPOFF']) #in km time_take = utils.drive_time(distance,args['SPEED']) isLate = utils.late(args['TIME'], time_take) if(isLate): messages.delayed( args['MESSAGE'], args['TOPHONE'], args['FROMPHONE'], args['ORDERID'] ) else: messages.timely(args['ORDERID'])
def pwy(settings):
show_diagnostics = True;
settings = utils.process_args(settings, show_diagnostics)
# OPEN FILE
settings['filename'] = UPLOAD_FOLDER+'/'+settings['filename']
UI_instrument_notes = settings['inst1']; UI_onset_threshold = settings['busy'];
UI_instrument_chords = settings['inst2']; UI_dynamic_threshold = settings['dyn'];
UI_instrument_beats = settings['inst3']; UI_beat_windowSize = settings['window']; #300 msec
UI_beat_pattern = settings['pattern']; UI_chord_style = settings['style'];
UI_time_signature = settings['timeSig']; y, sr = librosa.load(settings['filename'])
# TRACK BEATS
onsets, beats, volume_notes, times, tempo, msec_tempo = beatDetection.track_beats(y, sr, UI_onset_threshold, UI_dynamic_threshold, UI_beat_windowSize)
#beatDetection.plot_beats_and_onsets(onsets, beats, times, show_diagnostics) //Breaks GUI
# PREDICT CHORDS
notes, reg_notes, startTimes_notes, endTimes_notes, frameIndex_notes = chordPrediction.get_chords(settings['filename'], times[beats], times)
chords, reg_chords, startTimes_chords, endTimes_chords, frameIndex_chords, volume_chords = midiConversion.determine_durations(list(notes), list(reg_notes), list(startTimes_notes), list(endTimes_notes), frameIndex_notes, list(volume_notes))
chordPrediction.print_chords_and_times(chords, startTimes_chords, endTimes_chords, frameIndex_chords, times, show_diagnostics)
startTimes_beats, endTimes_beats, volume_beats = beatDetection.alter_beats(startTimes_notes, endTimes_notes, volume_notes, msec_tempo, UI_beat_windowSize, settings['speed'])
# NOTES TO MIDI
midi_notes = midiConversion.convert_note_to_midi(notes, reg_notes)
midi_chords = midiConversion.convert_chord_to_midi(chords, reg_chords, UI_chord_style)
midi_beats = midiConversion.convert_beat_to_midi(notes, UI_beat_pattern, UI_time_signature, UI_instrument_beats, reg_notes, settings['speed'])
# WRITE MIDI
midi_tracks = [midi_notes, midi_chords, midi_beats]
startTimes = [startTimes_notes, startTimes_chords, startTimes_beats]
endTimes = [endTimes_notes, endTimes_chords, endTimes_beats]
UI_instrument = [UI_instrument_notes, UI_instrument_chords, UI_instrument_beats]
volumes = [volume_notes, volume_chords, volume_beats]
duration = [0]*len(midi_tracks); program = [0]*len(midi_tracks); volume = [0]*len(midi_tracks);
for i in range(len(midi_tracks)):
duration[i], program[i], volume[i] = midiFileCreation.build_track(UI_instrument[i], midi_tracks[i], startTimes[i], endTimes[i], volumes[i], msec_tempo, UI_dynamic_threshold)
midiFileCreation.write_midi_file(settings['filename'], midi_tracks, program, duration, tempo[0], volume)
utils.preview(ntpath.basename(settings['filename']), UPLOAD_FOLDER)
return render_template('download.html', filename=ntpath.basename(settings['filename'][:-4]), path=UPLOAD_FOLDER)
def parse_args():
parser = argparse.ArgumentParser(description='Options for MVNet')
parser.add_argument('--log', type=str, default=None)
parser.add_argument('--test_batch_size', type=int, default=4)
parser.add_argument('--test_im_batch', type=int, default=4)
parser.add_argument('--ckpt', type=str, default=None)
parser.add_argument('--split', type=str, default='test')
parser.add_argument('--test_views_file', type=str, default=None)
parser.add_argument('--result_file', type=str, default=None)
parser.add_argument('--loglevel', type=str, default='info')
parser.add_argument('--test_split_file',
type=str,
default='data/splits.json')
parser.add_argument('--prefetch_threads', type=int, default=2)
parser.add_argument('--savedir', type=str, default=None)
parser.add_argument('--vis', action="store_true")
args = process_args(parser)
return args
def parse_args():
parser = argparse.ArgumentParser(description='Options for MVNet')
parser.add_argument('--argsjs', type=str, default=None)
parser.add_argument('--custom_training', type=str, default=True)
parser.add_argument('--logdir', type=str, default='./log')
parser.add_argument('--batch_size', type=int, default=4)
parser.add_argument('--loglevel', type=str, default='info')
parser.add_argument('--im_batch', type=int, default=4)
parser.add_argument('--prefetch_threads', type=int, default=2)
parser.add_argument('--im_h', type=int, default=224)
parser.add_argument('--im_w', type=int, default=224)
parser.add_argument('--im_net',
type=str,
default='unet',
choices=im_nets.keys())
parser.add_argument('--grid_net',
type=str,
default='unet32',
choices=grid_nets.keys())
parser.add_argument('--rnn',
type=str,
default='gru',
choices=conv_rnns.keys())
parser.add_argument('--nvox', type=int, default=32)
parser.add_argument('--ray_samples', type=int, default=64)
parser.add_argument('--proj_x', type=int, default=4, choices=[4, 8])
parser.add_argument('--norm', type=str, default='IN')
parser.add_argument('--ckpt', type=str, default=None)
parser.add_argument('--split_file', type=str, default=None)
parser.add_argument('--lr', type=float, default=1e-3)
parser.add_argument('--decay_rate', type=float, default=1)
parser.add_argument('--decay_steps', type=int, default=10000)
parser.add_argument('--beta1', type=float, default=0.9)
parser.add_argument('--niters', type=int, default=100000)
parser.add_argument('--sum_iters', type=int, default=50)
parser.add_argument('--ckpt_iters', type=int, default=5000)
parser.add_argument('--im_skip', action="store_true")
parser.add_argument('--sepup', action="store_true")
parser.add_argument('--rng_seed', type=int, default=0)
parser.add_argument('--run_trace', action="store_true")
args = process_args(parser)
return args
bestsaver.save(sess, args.save_dir_best_model,
global_step=global_step)
tqdm.write("\t done.")
finalperf = evalperf
val_perf.append((loss, evalperf))
is_start = False
loss, _, xyloss, act_loss, traj_class_loss, grid_loss = \
trainer.step(sess, batch)
if math.isnan(loss):
print("nan loss.")
print(grid_loss)
sys.exit()
if global_step % save_period != 0:
saver.save(sess, args.save_dir_model, global_step=global_step)
print("best eval on val %s: %s at %s step, final step %s %s is %s" % (
metric, best[metric], best["step"], global_step, metric,
finalperf[metric]))
if __name__ == "__main__":
arguments = parser.parse_args()
arguments.is_train = True
arguments.is_test = False
arguments = utils.process_args(arguments)
main(arguments)
print('==> Start training ..')
best_auroc = 0.
start = time.time()
for epoch in range(args.maxepoch):
train(epoch, adversarial_loss, pixelwise_loss, encoder, decoder, discriminator, trainloader, optimizer_G, optimizer_D, scheduler_G, scheduler_D, logger, device)
auroc, aupr, _ = test(encoder, decoder, testloader, device)
print('Epoch: %4d AUROC: %.4f AUPR: %.4f'%(epoch, auroc, aupr))
logger.write('Epoch: %4d AUROC: %.4f AUPR: %.4f \n'%(epoch, auroc, aupr))
state = {
'encoder': encoder.state_dict(),
'decoder': decoder.state_dict(),
'discriminator': discriminator.state_dict(),
'auroc': auroc,
'epoch': epoch}
torch.save(state, chpt_name)
end = time.time()
hours, rem = divmod(end-start, 3600)
minutes, seconds = divmod(rem, 60)
print('AUROC... ', auroc)
print("Elapsed Time: {:0>2}:{:0>2}:{:05.2f}".format(int(hours),int(minutes),seconds))
logger.write("AUROC: %.8f\n"%(auroc))
logger.write("Elapsed Time: {:0>2}:{:0>2}:{:05.2f}\n".format(int(hours),int(minutes),seconds))
if __name__ == '__main__':
args = utils.process_args()
main(args)
def do_analysis(
rdata_load='Periodicity.rda', selected_lengths='27',
selected_frames='', hit_mean='10', unique_hit_mean='1',
ratio_check='TRUE', min5p='-20', max5p='200', min3p='-200', max3p='20',
cap='', plot_title='', plot_lengths='27', rdata_save='Metagene.rda',
html_file='Metagene-report.html', output_path=os.getcwd()):
"""Metagene analysis from saved periodicity R data file. """
run_rscript('suppressMessages(library(riboSeqR))')
run_rscript('load("{}")'.format(rdata_load))
logging.debug('fS\n{}\nfCs\n{}\n'.format(R['fS'], R['fCs']))
options = {}
for key, value, rtype, rmode in (
('lengths', selected_lengths, 'int', 'charvector'),
('frames', selected_frames, 'int', 'listvector'),
('hit_mean', hit_mean, 'int', None),
('unique_hit_mean', unique_hit_mean, 'int', None),
('ratio_check', ratio_check, 'bool', None),
('min5p', min5p, 'int', None), ('max5p', max5p, 'int', None),
('min3p', min3p, 'int', None), ('max3p', max3p, 'int', None),
('cap', cap, 'int', None),
('plot_title', plot_title, 'str', 'charvector'),
('plot_lengths', plot_lengths, 'int', 'list')):
options[key] = utils.process_args(
value, ret_type=rtype, ret_mode=rmode)
cmd_args = """fCs, lengths={lengths},
frames={frames}, hitMean={hit_mean},
unqhitMean={unique_hit_mean}, fS=fS""".format(**options)
if ratio_check == 'TRUE':
cmd_args += ', ratioCheck = TRUE'
run_rscript('ffCs <- filterHits({})'.format(cmd_args))
logging.debug("ffCs\n{}\n".format(R['ffCs']))
cds_args = ('coordinates=ffCs@CDS, riboDat=riboDat, min5p={min5p}, '
'max5p={max5p}, min3p={min3p}, max3p={max3p}'.format(**options))
if options['cap']:
cds_args += ', cap={cap}'.format(**options)
if options['plot_title']:
cds_args += ', main={plot_title}'.format(**options)
html = """<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<title>Metagene Analysis - Report</title>
</head>
<body>
"""
html += '<h2>Metagene analysis - results</h2>\n<hr>\n'
html += ('<p>\nLengths of footprints used in analysis - <strong>'
'<code>{0}</code></strong><br>\nLengths of footprints '
'selected for the plot - <strong><code>{1}</code></strong>'
'\n</p>\n'.format(selected_lengths, plot_lengths))
for count, length in enumerate(options['plot_lengths']):
count += 1
html += '<h3>Length: {0}</h3>\n'.format(length)
plot_file = os.path.join(output_path,
'Metagene-analysis-plot{0}'.format(count))
for fmat in ('pdf', 'png'):
if fmat == 'png':
cmd = 'png(file="{0}_%1d.png", type="cairo")'
else:
cmd = 'pdf(file="{0}.pdf")'
run_rscript(cmd.format(plot_file))
run_rscript('plotCDS({0},{1})'.format(
cds_args, 'lengths={}'.format(length)))
run_rscript('dev.off()')
for image in sorted(
glob.glob('{}*.png'.format(plot_file))):
html += '<p><img border="1" src="{0}" alt="{0}"></p>\n'.format(
os.path.basename(image))
html += '<p><a href="{0}.pdf">PDF version</a></p>\n'.format(
os.path.basename(plot_file))
run_rscript('save("ffCs", "riboDat", "fastaCDS", file="{}", '
'compress=FALSE)'.format(rdata_save))
logging.debug('\n{:#^80}\n{}\n{:#^80}\n'.format(
' R script for this session ', rscript, ' End R script '))
with open(os.path.join(output_path, 'metagene.R'), 'w') as r:
r.write(rscript)
html += ('<h4>R script for this session</h4>\n'
'<p><a href="metagene.R">metagene.R</a></p>\n'
'<p>Next step: <em>Plot Ribosome profile</em></p>\n'
'</body>\n</html>\n')
with open(html_file, 'w') as f:
f.write(html)
def parse_args():
# Parameters for both testing and training
parser = argparse.ArgumentParser(description='Options for SilhoNet')
parser.add_argument('--mode',
required=True,
type=str,
choices=MODE_LIST,
help='mode for running network')
parser.add_argument('--argsjs',
type=str,
default=None,
help='path to json args file')
parser.add_argument(
'--logdir',
type=str,
default='./log',
help='logging directory. Automatically appends ' +
'$DATE/train/ to path for training when not running from a checkpoint')
parser.add_argument('--loglevel',
type=str,
default='info',
help='logging level: error, info, warn, debug')
parser.add_argument('--batch_size',
type=int,
default=4,
help='input image batch size')
parser.add_argument(
'--mdl_im_batch',
type=int,
default=12,
help=
'number of rendered model images per ROI detection for silhouette prediction'
)
parser.add_argument(
'--prefetch_threads',
type=int,
default=2,
help='number of threads for processing dataset into queue')
parser.add_argument('--prefetch_qsize',
type=int,
default=32,
help='maximum size of input queue')
parser.add_argument('--mdl_im_h',
type=int,
default=224,
help='height of model input image')
parser.add_argument('--mdl_im_w',
type=int,
default=224,
help='width of model input image')
parser.add_argument('--im_h',
type=int,
default=480,
help='height of input image')
parser.add_argument('--im_w',
type=int,
default=640,
help='width of input image')
parser.add_argument(
'--roi_size',
type=int,
default=64,
help='size of output silhouette masks. Also size of resized ROIs')
parser.add_argument('--roi_area_thresh',
type=float,
default=10,
help='minimum area of detected ROI')
parser.add_argument(
'--roi_fill_thresh',
type=float,
default=0.01,
help='minimum percentage of ROI area where detected object is visible')
parser.add_argument(
'--norm',
type=str,
default='IN',
help='layer normalization: Instance Norm: IN, Batch Norm: BN., or None'
)
parser.add_argument('--ckpt', type=str, default=None, help='checkpoint')
parser.add_argument('--seg_ckpt',
type=str,
default=None,
help='heckpoint for silhouette prediction stage only')
parser.add_argument('--gpus',
type=str,
default="0",
help='GPUs visible to Tensorflow')
parser.add_argument('--shuffle',
action="store_true",
help='shuffle dataset')
parser.add_argument(
'--num_classes',
type=int,
default=22,
help='number of classes in dataset including background class')
parser.add_argument(
'--threshold_mask',
action="store_false",
help='threshold probability silhouette predictions into binary masks')
parser.add_argument('--im_net',
type=str,
default='vgg16',
choices=im_nets.keys(),
help='feature extraction network')
parser.add_argument('--seg_net',
type=str,
default='stack',
choices=seg_nets.keys(),
help='silhouette prediction network')
parser.add_argument('--quat_net',
type=str,
default='quat_res',
choices=quat_nets.keys(),
help='3D pose regression network')
parser.add_argument('--quat_loss',
type=str,
default='log_dist',
choices=quat_losses.keys(),
help='oss function for 3D pose regression')
# Parameters for training only
parser.add_argument('--lr',
type=float,
default=1e-3,
help='initial learning rate')
parser.add_argument('--decay_rate',
type=float,
default=1,
help='learning rate decay rate')
parser.add_argument('--decay_steps',
type=int,
default=10000,
help='period to apply learning rate decay')
parser.add_argument('--niters',
type=int,
default=10000,
help='iterations to train')
parser.add_argument('--niters_val',
type=int,
default=1000,
help='period of iterations to run validation')
parser.add_argument('--sum_iters',
type=int,
default=50,
help='period of iterations to run summery')
parser.add_argument('--ckpt_iters',
type=int,
default=5000,
help='period of iterations to save checkpoint')
parser.add_argument(
'--val_iters',
type=int,
default=100,
help='iterations over which to calculate validation loss')
parser.add_argument('--rng_seed', type=int, default=0, help='random seed')
parser.add_argument(
'--nepochs',
type=int,
default=None,
help=
'number of epochs to train. If None, network trains for niters. If not None, netowrk trains '
+ 'for which comes first, niters or nepochs')
parser.add_argument('--keep_prob',
type=float,
default=0.5,
help='keep probability for dropout')
parser.add_argument('--run_val',
action="store_true",
help='run validation during training')
parser.add_argument('--vis_gradients',
action="store_true",
help='visualize layer gradients during training')
parser.add_argument('--run_trace',
action="store_true",
help='run trace on network termination')
parser.add_argument(
'--use_pretrained',
action="store_true",
help=
'use pretrained imagenet weights for initializing VGG16 backbone network'
)
# Parameters for testing only
parser.add_argument(
'--eval_thresh',
type=float,
nargs='+',
help=
'list of threshold values at which to evaluate test performance. For silhouette '
+
'prediction, values are used to threshold probability masks into binary masks. For 3D pose prediction, threshold values are maximum angle errors in degrees.'
)
parser.add_argument('--split',
type=str,
default='keyframe',
help='image set to evaluate.')
args = process_args(parser)
return args
def simulate():
args = utils.process_args(vars(utils.parser.parse_args()))
print(args)
Ns, densities, solvers, budgets, nsim, costType, verbose, loadPrev, standardize = args
result_dict = []
result_colnums_names = [
'N', 'Density', 'Solver', 'Budget', 'Cost', 'Time_avg', 'Time_sd',
'Sol_avg', 'Sol_sd'
]
total_simulations = utils.getTotalSimulation(
[Ns, densities, budgets, costType])
total_simulations *= nsim
progress = 0
loadPrev_outer = loadPrev
try:
for N in Ns:
for density in densities:
for budget in budgets:
for cost in costType:
sols = np.zeros((nsim, len(solvers)))
times = np.zeros((nsim, len(solvers)))
if loadPrev:
try:
print(
"\nLoading previously saved test instances..."
)
try:
update_cost = False
sims, new_budget = utils.load_saved_instance(
N, density, budget, cost)
except:
print("Need to update costs...")
update_cost = True
sims, new_budget = utils.load_saved_instance(
N, density, budget, None)
except:
print(
"Failed to load... Creating new instances..."
)
sims = []
loadPrev = False
else:
print("Creating new instances...")
sims = []
for sim in range(nsim):
if loadPrev and sim < len(sims):
changed_instance = False
G, B, U, C = sims[sim]
if update_cost:
print("\nUpdating costs...")
C = generate_cost(G, cost)
sims[sim] = G, B, U, C
changed_instance = True
if new_budget:
print(
"\nReusing test cases but with different budget..."
)
B = 5 * G.order() * budget
else:
changed_instance = True
G = generate_random_dag(N, density)
B = 5 * N * budget
U = generate_utility(G)
C = generate_cost(G, cost)
sims.append((G, B, U, C))
for solver_index in range(len(solvers)):
solver = solvers[solver_index]
if solver == "ilp":
if cost == "monotone":
C_ilp = C[0]
s_time, s_sol = ilp_time(G, C[0], B, U)
elif cost == "add":
s_time, s_sol = ilp_time(G, C, B, U)
elif solver == "bf":
s_time, s_sol = brute_force_time(
G, C, B, U, cost)
elif solver == "gd":
s_time, s_sol = greedy_time(
G, C, B, U, cost)
elif solver == "gd2":
s_time, s_sol = greedy2_time(
G, C, B, U, cost)
sols[sim, solver_index] = s_sol
times[sim, solver_index] = s_time
progress += 1
if verbose:
utils.update_progress(progress /
total_simulations)
if changed_instance or new_budget:
print("\nTest instances saved for future use.")
utils.save_instance(sims, N, density, budget, cost)
result_dict.extend(
utils.generate_result_dict(N, density, budget,
cost, solvers, sols,
times, standardize))
loadPrev = loadPrev_outer
utils.export(result_colnums_names, result_dict)
except KeyboardInterrupt:
utils.export(result_colnums_names, result_dict)
def find_periodicity(
rdata_load='Prepare.rda', start_codons='ATG', stop_codons='TAG,TAA,TGA',
fasta_file=None, include_lengths='25:30', analyze_plot_lengths='26:30',
text_legend='Frame 0, Frame 1, Frame 2', rdata_save='Periodicity.rda',
html_file='Periodicity-report.html', output_path=os.getcwd()):
"""Plot triplet periodicity from prepared R data file. """
logging.debug('{}'.format(R('sessionInfo()')))
cmd = 'suppressMessages(library(riboSeqR))'
run_rscript(cmd)
logging.debug('Loading saved R data file')
cmd = 'load("{}")'.format(rdata_load)
run_rscript(cmd)
# R("""options(showTailLines=Inf)""")
starts, stops = (utils.process_args(start_codons, ret_mode='charvector'),
utils.process_args(stop_codons, ret_mode='charvector'))
cmd = ('fastaCDS <- findCDS(fastaFile={0!r}, startCodon={1}, '
'stopCodon={2})'.format(fasta_file, starts, stops))
run_rscript(cmd)
logging.debug('Potential coding sequences using start codon (ATG) and '
'stop codons TAG, TAA, TGA')
logging.debug('{}\n'.format(R['fastaCDS']))
cmd = """fCs <- frameCounting(riboDat, fastaCDS, lengths={0})
fS <- readingFrame(rC=fCs, lengths={1}); fS""".\
format(include_lengths, analyze_plot_lengths)
run_rscript(cmd)
logging.debug('riboDat \n{}\n'.format(R['riboDat']))
logging.debug('fCs\n{0}\n'.format(R['fCs']))
logging.debug('Reading frames for each n-mer\n{}'.format(R['fS']))
legend = utils.process_args(text_legend, ret_mode='charvector')
for fmat in ('pdf', 'png'):
if fmat == 'png':
cmd = '{0}(file="{1}", type="cairo")'
else:
cmd = '{0}(file="{1}")'
run_rscript(cmd.format(fmat, os.path.join(
output_path, '{0}.{1}'.format('Periodicity-plot', fmat))))
run_rscript('plotFS(fS, legend.text = {0})'.format(legend))
run_rscript('dev.off()')
run_rscript('save("fCs", "fS", "riboDat", "fastaCDS", '
'file="{}", compress=FALSE)'.format(rdata_save))
html = '<h2>Triplet periodicity - results</h2><hr>'
html += ('<h4>Results of reading frame analysis</h4>'
'<pre>{}</pre><br>'.format(R['fS']))
html += ('<p>Lengths used for reading frame analysis - <code>{0}</code>'
'<br>Lengths selected for the plot - <code>{1}</code>'
'</p>'.format(include_lengths, analyze_plot_lengths))
html += ('<p><img src="Periodicity-plot.png" border="1" '
'alt="Triplet periodicity plot" />'
'<br><a href="Periodicity-plot.pdf">PDF version</a></p>')
logging.debug('\n{:#^80}\n{}\n{:#^80}\n'.format(
' R script for this session ', rscript, ' End R script '))
with open(os.path.join(output_path, 'periodicity.R'), 'w') as r:
r.write(rscript)
html += ('<h4>R script for this session</h4>'
'<p><a href="periodicity.R">periodicity.R</a></p>'
'<p>Next step: <em>Metagene analysis</em></p>')
with open(html_file, 'w') as f:
f.write(html)
def plot_transcript(
rdata_load="Metagene.rda",
transcript_name="",
transcript_length="27",
transcript_cap="",
html_file="Plot-ribosome-profile.html",
output_path=os.getcwd(),
):
"""Plot ribosome profile for a given transcript. """
options = {}
for key, value, rtype, rmode in (
("transcript_name", transcript_name, "str", None),
("transcript_length", transcript_length, "int", "charvector"),
("transcript_cap", transcript_cap, "int", None),
):
options[key] = utils.process_args(value, ret_type=rtype, ret_mode=rmode)
run_rscript("suppressMessages(library(riboSeqR))")
run_rscript('load("{}")'.format(rdata_load))
html = """<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<title>Ribosome Profile Plot - Report</title>
</head>
<body>
"""
html += "<h2>Plot ribosome profile - results</h2>\n<hr>\n"
if len(transcript_name):
cmd_args = (
'"{transcript_name}", main="{transcript_name}",'
"coordinates=ffCs@CDS, riboData=riboDat,"
"length={transcript_length}".format(**options)
)
if transcript_cap:
cmd_args += ", cap={transcript_cap}".format(**options)
plot_file = os.path.join(output_path, "Ribosome-profile-plot")
for fmat in ("pdf", "png"):
if fmat == "png":
cmd = 'png(file="{}_%1d.png", type="cairo")'.format(plot_file)
else:
cmd = 'pdf(file="{}.pdf")'.format(plot_file)
run_rscript(cmd)
cmd = "plotTranscript({})".format(cmd_args)
run_rscript(cmd)
run_rscript("dev.off()")
html += "<p>Selected ribosome footprint length: " "<strong>{0}</strong>\n".format(transcript_length)
for image in sorted(glob.glob("{}_*.png".format(plot_file))):
html += '<p><img border="1" src="{0}" alt="{0}"></p>\n'.format(os.path.basename(image))
html += '<p><a href="Ribosome-profile-plot.pdf">PDF version</a></p>\n'
else:
msg = "No transcript name was provided. Did not generate plot."
html += "<p>{}</p>".format(msg)
logging.debug(msg)
logging.debug("\n{:#^80}\n{}\n{:#^80}\n".format(" R script for this session ", rscript, " End R script "))
with open(os.path.join(output_path, "ribosome-profile.R"), "w") as r:
r.write(rscript)
html += (
"<h4>R script for this session</h4>\n"
'<p><a href="ribosome-profile.R">ribosome-profile.R</a></p>\n'
"</body>\n</html>\n"
)
with open(html_file, "w") as f:
f.write(html)
starttime = datetime.now()
# AllChem.GetMorganFingerprint(reference,2)
# FingerprintMols.FingerprintMol(reference)
# FingerprintMols.GetRDKFingerprint
Fingerprint = FingerprintMols.FingerprintMol
reference = Chem.MolFromSmiles(args.reference_mol)
fp_reference = Fingerprint(reference)
ref = fp_reference
print(f"Fingerprint length: {ref.GetNumBits()}")
_cwd, inpath, outpath, inputs = process_args(args)
# Not cached:
def process_row_str(row: str, ref=ref):
"""
Inputs:
row: str
First two tab-seperated entries of string are the
SMILES and ID of the row.
Return:
str:
If the tanimoto threshold is passed, return the
smile, the id and the tanimoto coef. in smiles-format:
"SMILES\tID\tTANIMOTOCOEF"
"""
def generate_ribodata(ribo_files='', rna_files='', replicate_names='',
seqnames='', rdata_save='Prepare.rda', sam_format=True,
html_file='Prepare-report.html', output_path=os.getcwd()):
"""Prepares Ribo and RNA seq data in the format required for riboSeqR. Calls
the readRibodata function of riboSeqR and saves the result objects in an
R data file which can be used as input for the next step.
"""
input_ribo_files = utils.process_args(ribo_files, ret_mode='list')
logging.debug('Found {} Ribo-Seq files'.format(len(input_ribo_files)))
logging.debug(input_ribo_files)
input_rna_files = []
if rna_files:
input_rna_files = utils.process_args(rna_files, ret_mode='list')
logging.debug('Found {} RNA-Seq files'.format(len(input_rna_files)))
logging.debug(input_rna_files)
replicates = utils.process_args(replicate_names, ret_mode='charvector')
logging.debug('Replicates: {}\n'.format(replicates))
if sam_format:
ribo_seq_files = batch_process(input_ribo_files, 'riboseq', output_path)
else:
ribo_seq_files = input_ribo_files
html = '<h2>Prepare riboSeqR input - results</h2><hr>'
if len(ribo_seq_files):
html += '<h4>Generated riboSeqR format input files ' \
'<em>(RiboSeq)</em></h4><p>'
for fname in ribo_seq_files:
html += '<a href="{0}">{0}</a><br>'.format(
os.path.basename(fname))
html += '</p>'
rna_seq_files = []
if len(input_rna_files):
if sam_format:
rna_seq_files = batch_process(
input_rna_files, 'rnaseq', output_path)
else:
rna_seq_files = input_rna_files
if len(rna_seq_files):
html += ('<h4>Generated riboSeqR format input files '
'<em>(RNASeq)</em></h4><p>')
for fname in rna_seq_files:
html += '<a href="{0}">{0}</a><br>'.format(
os.path.basename(fname))
html += '</p>'
input_seqnames = utils.process_args(seqnames, ret_mode='charvector')
options = {'ribo_seq_files': 'c({})'.format(str(ribo_seq_files)[1:-1]),
'rna_seq_files': 'c({})'.format(str(rna_seq_files)[1:-1]),
'input_replicates': replicates,
'input_seqnames': input_seqnames}
logging.debug('{}'.format(R('sessionInfo()')))
script = ''
cmd = 'suppressMessages(library(riboSeqR))'
run_rscript(cmd)
script += '{}\n'.format(cmd)
if len(rna_seq_files):
cmd_args = ('riboFiles={ribo_seq_files}, '
'rnaFiles={rna_seq_files}'.format(**options))
else:
cmd_args = 'riboFiles={ribo_seq_files}'.format(**options)
if input_seqnames:
cmd_args += ', seqnames={input_seqnames}'.format(**options)
if replicates:
cmd_args += ', replicates={input_replicates}'.format(**options)
else:
cmd_args += ', replicates=c("")'
cmd = 'riboDat <- readRibodata({0})'.format(cmd_args)
run_rscript(cmd)
script += '{}\n'.format(cmd)
ribo_data = R['riboDat']
logging.debug('riboDat \n{}\n'.format(ribo_data))
cmd = 'save("riboDat", file="{}", compress=FALSE)'.format(rdata_save)
run_rscript(cmd)
script += '{}\n'.format(cmd)
msg = '\n{:#^80}\n{}\n{:#^80}\n'.format(
' R script for this session ', script, ' End R script ')
logging.debug(msg)
with open(os.path.join(output_path, 'prepare.R'), 'w') as r:
r.write(script)
html += ('<h4>R script for this session</h4>'
'<p><a href="prepare.R">prepare.R</a></p>'
'<p>Next step: <em>Triplet periodicity</em></p>')
with open(html_file, 'w') as f:
f.write(html)
return ribo_data
