def test_repeat(): # Build up inputs for cat1 as_dict = inputs().set("input1", dataset("encoded1")).set( "queries", repeat().instance(inputs().set_dataset_param( "input2", "encoded2")).instance(inputs().set_dataset_param( "input2", "encoded3"))).to_dict() assert as_dict["input1"]["src"] == "hda" assert as_dict["input1"]["id"] == "encoded1" assert as_dict["queries_0|input2"]["src"] == "hda" assert as_dict["queries_0|input2"]["id"] == "encoded2" assert as_dict["queries_1|input2"]["src"] == "hda" assert as_dict["queries_1|input2"]["id"] == "encoded3"
def test_run_cat1(self): history_id = self.gi.histories.create_history( name="test_run_cat1 history")["id"] dataset1_id = self._test_dataset(history_id, contents="1 2 3") dataset2_id = self._test_dataset(history_id, contents="4 5 6") dataset3_id = self._test_dataset(history_id, contents="7 8 9") tool_inputs = inputs().set("input1", dataset(dataset1_id)).set( "queries", repeat().instance(inputs().set( "input2", dataset(dataset2_id))).instance(inputs().set( "input2", dataset(dataset3_id)))) tool_output = self.gi.tools.run_tool(history_id=history_id, tool_id="cat1", tool_inputs=tool_inputs) self.assertEqual(len(tool_output["outputs"]), 1)
def fetch_sequences_and_get_dataset_id(dataset, gi, logger): start = time.time() logger.info( f"Fetching DNA sequences from {colored(dataset.genome_build, 'blue')} in {colored('fasta', 'blue')} format..." ) dataset_name = dataset.name dataset_id = dataset.id hist_id = dataset.container_id tool_id = 'Extract genomic DNA 1' tool_input = inputs().set_dataset_param(dataset_name, dataset_id, src="hda") job = gi.tools.run_tool(history_id=hist_id, tool_id=tool_id, tool_inputs=tool_input) job_id = job['jobs'][0]['id'] dataset_id = job['outputs'][0]['id'] while True: job_state = gi.jobs.get_state(job_id) if job_state == 'ok': break time.sleep(30) end = time.time() job_time = f'{str(datetime.timedelta(seconds=int(end - start)))}' logger.info(f"Extraction completed in {colored(job_time, 'blue')}") return dataset_id
def test_repeat(): # Build up inputs for cat1 as_dict = inputs().set( "input1", dataset("encoded1") ).set( "queries", repeat().instance( inputs().set_dataset_param("input2", "encoded2") ).instance( inputs().set_dataset_param("input2", "encoded3") ) ).to_dict() assert as_dict["input1"]["src"] == "hda" assert as_dict["input1"]["id"] == "encoded1" assert as_dict["queries_0|input2"]["src"] == "hda" assert as_dict["queries_0|input2"]["id"] == "encoded2" assert as_dict["queries_1|input2"]["src"] == "hda" assert as_dict["queries_1|input2"]["id"] == "encoded3"
def test_run_cat1(self): history_id = self.gi.histories.create_history(name="test_run_cat1 history")["id"] dataset1_id = self._test_dataset(history_id, contents="1 2 3") dataset2_id = self._test_dataset(history_id, contents="4 5 6") dataset3_id = self._test_dataset(history_id, contents="7 8 9") tool_inputs = ( inputs() .set("input1", dataset(dataset1_id)) .set( "queries", repeat() .instance(inputs().set("input2", dataset(dataset2_id))) .instance(inputs().set("input2", dataset(dataset3_id))), ) ) tool_output = self.gi.tools.run_tool(history_id=history_id, tool_id="cat1", tool_inputs=tool_inputs) self.assertEqual(len(tool_output["outputs"]), 1)
def test_wait_for_job(self): tool_inputs = inputs().set("input1", dataset(self.dataset_id)) tool_output = self.gi.tools.run_tool(history_id=self.history_id, tool_id="cat1", tool_inputs=tool_inputs) job_id = tool_output['jobs'][0]['id'] job = self.gi.jobs.wait_for_job(job_id) self.assertEqual(job['state'], 'ok')
def test_conditional(): # Build up example inputs for random_lines1 as_dict = inputs().set("num_lines", 5).set( "input", dataset("encoded1")).set( "seed_source", conditional().set("seed_source_selector", "set_seed").set("seed", "asdf")).to_dict() assert as_dict["num_lines"] == 5 assert as_dict["input"]["src"] == "hda" assert as_dict["input"]["id"] == "encoded1" assert as_dict["seed_source|seed_source_selector"] == "set_seed" assert as_dict["seed_source|seed"] == "asdf"
def export_output(request, project, gi, file_id, tool_id="export_sbw"): """Export data in galaxy MetaGenSense output directory""" """add the name of project on file name""" data = gi.datasets.show_dataset(dataset_id=file_id) hist_id = data['history_id'] myinputs = inputs().set("prefix", project).set("input", dataset(file_id)) tool_outputs = gi.tools.run_tool(history_id=hist_id, tool_id=tool_id, tool_inputs=myinputs) if tool_outputs: messages.warning(request, "Export is in progress, your file will be available: " + project + '_' + data['name']) return redirect('galaxy_history_detail', history_id=hist_id)
def test_run_random_lines(self): # Run second test case from randomlines.xml history_id = self.gi.histories.create_history(name="test_run_random_lines history")["id"] with open(get_abspath(os.path.join("data", "1.bed"))) as f: contents = f.read() dataset_id = self._test_dataset(history_id, contents=contents) tool_inputs = ( inputs() .set("num_lines", "1") .set("input", dataset(dataset_id)) .set("seed_source", conditional().set("seed_source_selector", "set_seed").set("seed", "asdf")) ) tool_output = self.gi.tools.run_tool(history_id=history_id, tool_id="random_lines1", tool_inputs=tool_inputs) self.assertEqual(len(tool_output["outputs"]), 1)
def test_run_random_lines(self): # Run second test case from randomlines.xml history_id = self.gi.histories.create_history( name="test_run_random_lines history")["id"] with open(test_util.get_abspath(os.path.join("data", "1.bed"))) as f: contents = f.read() dataset_id = self._test_dataset(history_id, contents=contents) tool_inputs = inputs().set("num_lines", "1").set( "input", dataset(dataset_id)).set( "seed_source", conditional().set("seed_source_selector", "set_seed").set("seed", "asdf")) tool_output = self.gi.tools.run_tool(history_id=history_id, tool_id="random_lines1", tool_inputs=tool_inputs) self.assertEqual(len(tool_output["outputs"]), 1)
def test_conditional(): # Build up example inputs for random_lines1 as_dict = inputs().set( "num_lines", 5 ).set( "input", dataset("encoded1") ).set( "seed_source", conditional().set( "seed_source_selector", "set_seed" ).set( "seed", "asdf" ) ).to_dict() assert as_dict["num_lines"] == 5 assert as_dict["input"]["src"] == "hda" assert as_dict["input"]["id"] == "encoded1" assert as_dict["seed_source|seed_source_selector"] == "set_seed" assert as_dict["seed_source|seed"] == "asdf"
def tool_exec_view(request, pk, store_output=None): """ :param request: :param pk: :param store_output: :return: """ gi = request.galaxy message = "" tool_obj = get_object_or_404(Tool, pk=pk) toolfield, created = ToolFieldWhiteList.objects.get_or_create( tool=tool_obj, context='t') tool_visible_field = toolfield.saved_params tool_inputs_details = gi.tools.show_tool(tool_id=tool_obj.id_galaxy, io_details='true') tool_form = ToolForm(tool_params=tool_inputs_details['inputs'], tool_id=pk, whitelist=tool_visible_field, data=request.POST or None, session_files=request.session.get('files')) hid = {} if request.method == 'POST': if tool_form.is_valid(): try: wksph = None tool_inputs = inputs() # mapping between form id to galaxy params names fields = tool_form.fields_ids_mapping exts = tool_form.fields_ext_mapping inputs_data = set(tool_form.input_file_ids) for key, value in request.POST.items(): if not key in inputs_data: tool_inputs.set_param(fields.get(key), value) for inputfile in inputs_data: outputs = "" uploaded_file = "" if request.FILES: uploaded_file = request.FILES.get(inputfile, '') if uploaded_file: tmp_file = tempfile.NamedTemporaryFile() for chunk in uploaded_file.chunks(): tmp_file.write(chunk) tmp_file.flush() # send file to galaxy after verifying the # allowed extensions type = detect_type(tmp_file.name) if type in [ "fasta", "phylip" ] and nb_sequences(tmp_file.name, type) <= 3: raise ValueError( 'Sequence file %s should contain more than 3 sequences for field %s' % (uploaded_file.name, fields.get(inputfile))) if type in exts.get(inputfile, ""): if wksph is None: wksph = create_history(request, name="Analyse with " + tool_obj.name) outputs = gi.tools.upload_file( path=tmp_file.name, file_name=uploaded_file.name, history_id=wksph.history, file_type=type) else: raise ValueError( 'File format of file %s is not allowed for field %s' % (uploaded_file.name, fields.get(inputfile))) else: # else paste content content = request.POST.get(inputfile) galaxyfile = request.POST.get("galaxyfile_" + inputfile) if content: tmp_file = tempfile.NamedTemporaryFile() tmp_file.write(content) tmp_file.flush() # send file to galaxy after verifying the # allowed extensions input_fieldname = fields.get(inputfile) type = detect_type(tmp_file.name) if type in exts.get(inputfile, ""): if wksph is None: wksph = create_history( request, name="Analyse with " + tool_obj.name) outputs = gi.tools.upload_file( path=tmp_file.name, file_name=input_fieldname + " pasted_sequence", history_id=wksph.history, file_type=type) else: raise ValueError( 'This file format is not allowed for field %s' % (input_fieldname)) # Else we look at galaxy file ids else: if galaxyfile: file_id = galaxyfile hid[inputfile] = file_id if outputs: file_id = outputs.get('outputs')[0].get('id') hid[inputfile] = file_id for h, file_id in hid.items(): tool_inputs.set_dataset_param(fields.get(h), file_id) tool_outputs = gi.tools.run_tool(history_id=wksph.history, tool_id=tool_obj.id_galaxy, tool_inputs=tool_inputs) # Start monitoring (for sending emails) monitorworkspace.delay(wksph.history) wksph.monitored = True wksph.save() if store_output: request.session['output'] = tool_outputs return redirect( reverse_lazy("history_detail", kwargs={'history_id': wksph.history})) except ValueError as ve: message = str(ve) except ConnectionError as ce: message = str(ce) except NameError as ne: message = str(ne) except OperationalError as oe: message = str(oe) except AttributeError as ae: message = str(ae) except TypeError as te: message = str(te) except Exception as e: raw_message = ast.literal_eval(e.body) reverse_dict_field = { v: k for k, v in tool_form.fields_ids_mapping.items() } err_data = raw_message.get('err_data') if err_data: for field, err_msg in err_data.items(): tool_form.add_error( reverse_dict_field.get(field), ValidationError(err_msg, code='invalid')) else: message = raw_message delete_history(request, wksph.history) context = {"toolform": tool_form, "tool": tool_obj, "message": message} return render(request, 'tools/tool_form.html', context)
def launch_pasteur_blast(blastrunid, sequence, prog, db, evalue, coverage, maxseqs): """ Celery task that will launch a blast on the pasteur Galaxy Server """ logging.info("Blasting %s with %s on %s" % (sequence, prog, db)) b = BlastRun.objects.get(id=blastrunid) try: fasta_io = StringIO(sequence) records = list(SeqIO.parse(fasta_io, "fasta")) if len(records) == 1: galaxycon = galaxy_connection() galaxycon.nocache = True history = galaxycon.histories.create_history(name="BlastXplorer") b.history = history.get("id") b.query_id = biofile.cleanseqname(records[0].id) b.query_seq = records[0].seq b.evalue = evalue b.coverage = coverage b.database = db b.blastprog = prog b.maxseqs = maxseqs b.status = BlastRun.PENDING b.save() blast_type = BlastRun.blast_type(BlastRun.PASTEUR, prog) blast_inputtype = BlastRun.blast_inputtype(BlastRun.PASTEUR, prog) # We check alphabet of given sequence if ((blast_inputtype == "nt" and not biofile.check_nt(b.query_seq)) or (blast_inputtype == "aa" and not biofile.check_aa(b.query_seq))): b.status = BlastRun.ERROR b.message = "The given sequence has the wrong alphabet. Program %s expects %s sequence" % ( blast_type, blast_inputtype) elif blast_type is not None: tmp_file = tempfile.NamedTemporaryFile() tmp_file.write(sequence) tmp_file.flush() if biofile.is_fasta_one_seq(tmp_file.name): ## Upload input query file to galaxy outputs = galaxycon.tools.upload_file(path=tmp_file.name,file_name="blastinput.fasta",history_id=history.get("id"),file_type="fasta") file_id = outputs.get('outputs')[0].get('id') ## Configuring job tool_inputs=inputs() tool_inputs.set_dataset_param("query",file_id) tool_inputs.set_param("db_opts|database", db) tool_inputs.set_param("blast_type", blast_type) tool_inputs.set_param("evalue_cutoff", evalue) tool_inputs.set_param("output|out_format", "5") ## Running blast job outputs=galaxycon.tools.run_tool(history_id=history.get("id"),tool_id=prog,tool_inputs=tool_inputs) b.history_fileid = outputs.get("outputs")[0].get("id") else: b.status=BlastRun.ERROR b.message="Bad input FASTA file format" else: b.status=BlastRun.ERROR b.message="Wrong blast program %s" % (prog) b.save() else: b.status = BlastRun.ERROR b.message = "More than one record in the fasta file! %d" % ( len(list(records))) except Exception as e: logging.exception(str(e)) b.status = BlastRun.ERROR b.message = str(e) b.save() time.sleep(30)
def analyze_forms(self, request, context, workflow, params, gi, wksph, nseq, length, seqaa): steps = workflow.json['steps'] step_id = u'0' for tool_form in context['form_list']: if not tool_form.is_valid(): raise WorkflowInvalidFormError( "One form is invalid %s " % (tool_form.prefix)) tid = getattr(tool_form, 'tool_id', 'null') t=Tool.objects.get(id_galaxy=tid) tool_inputs = inputs() # mapping between form id to galaxy params names fields = tool_form.fields_ids_mapping inputs_data = set(tool_form.input_file_ids) # set the Galaxy parameter (name, value) nboot = 0 boot = False for key, value in tool_form.cleaned_data.items(): if key not in inputs_data: if fields.get(key,"") == 'bootstrap|replicates': nboot = value if fields.get(key,"") == 'bootstrap|do_bootstrap' and value == 'true': boot = True tool_inputs.set_param(fields.get(key), value) if not boot: nboot = 0 if not t.can_run_on_data(nseq, length, nboot, seqaa): raise WorkflowInputFileFormatError( "Input data is too large for the workflow" ) for inputfile in inputs_data: uploaded_file = "" if request.FILES: uploaded_file = request.FILES.get(inputfile, '') if uploaded_file: tmp_file = tempfile.NamedTemporaryFile() for chunk in uploaded_file.chunks(): tmp_file.write(chunk) tmp_file.flush() # send file to galaxy outputs = gi.tools.upload_file( path=tmp_file.name, file_name=uploaded_file.name, history_id=wksph.history) file_id = outputs.get('outputs')[0].get('id') tool_inputs.set_dataset_param( fields.get(inputfile), file_id) else: # else paste content content = tool_form.cleaned_data.get(inputfile) if content: tmp_file = tempfile.NamedTemporaryFile() tmp_file.write(content) tmp_file.flush() # send file to galaxy input_fieldname = tool_form.fields_ids_mapping.get( inputfile) outputs = gi.tools.upload_file( path=tmp_file.name, file_name=input_fieldname + " pasted_sequence", history_id=wksph.history) file_id = outputs.get('outputs')[0].get('id') tool_inputs.set_dataset_param(fields.get(inputfile), file_id) # workflow step # get from which step the tools are used for i, step in steps.items(): if (getattr(tool_form, 'tool_id', 'null') == step.get('tool_id')): step_id = i break # convert inputs to dict params[step_id] = tool_inputs.to_dict() if not params[step_id]: del params[step_id]
def analyze_forms(self, request, context, workflow, params, gi, wksph, nseq, length, seqaa): steps = workflow.json['steps'] step_id = u'0' for tool_form in context['form_list']: if not tool_form.is_valid(): raise WorkflowInvalidFormError("One form is invalid %s " % (tool_form.prefix)) tid = getattr(tool_form, 'tool_id', 'null') t = Tool.objects.get(id_galaxy=tid) tool_inputs = inputs() # mapping between form id to galaxy params names fields = tool_form.fields_ids_mapping inputs_data = set(tool_form.input_file_ids) # set the Galaxy parameter (name, value) nboot = 0 boot = False for key, value in tool_form.cleaned_data.items(): if key not in inputs_data: if fields.get(key, "") == 'bootstrap|replicates': nboot = value if fields.get( key, "" ) == 'bootstrap|do_bootstrap' and value == 'true': boot = True tool_inputs.set_param(fields.get(key), value) if not boot: nboot = 0 if not t.can_run_on_data(nseq, length, nboot, seqaa): raise WorkflowInputFileFormatError( "Input data is too large for the workflow") for inputfile in inputs_data: uploaded_file = "" if request.FILES: uploaded_file = request.FILES.get(inputfile, '') if uploaded_file: tmp_file = tempfile.NamedTemporaryFile() for chunk in uploaded_file.chunks(): tmp_file.write(chunk) tmp_file.flush() # send file to galaxy outputs = gi.tools.upload_file( path=tmp_file.name, file_name=uploaded_file.name.encode('ascii', 'ignore'), history_id=wksph.history) file_id = outputs.get('outputs')[0].get('id') tool_inputs.set_dataset_param(fields.get(inputfile), file_id) else: # else paste content content = tool_form.cleaned_data.get(inputfile) if content: tmp_file = tempfile.NamedTemporaryFile() tmp_file.write(content) tmp_file.flush() # send file to galaxy input_fieldname = tool_form.fields_ids_mapping.get( inputfile) outputs = gi.tools.upload_file( path=tmp_file.name, file_name=input_fieldname + " pasted_sequence", history_id=wksph.history) file_id = outputs.get('outputs')[0].get('id') tool_inputs.set_dataset_param(fields.get(inputfile), file_id) # workflow step # get from which step the tools are used for i, step in steps.items(): if (getattr(tool_form, 'tool_id', 'null') == step.get('tool_id')): step_id = i break # convert inputs to dict params[step_id] = tool_inputs.to_dict() if not params[step_id]: del params[step_id]
def launch_pasteur_blast(blastrunid, sequence, prog, db, evalue, coverage, maxseqs): """ Celery task that will launch a blast on the pasteur Galaxy Server """ logging.info("Blasting %s with %s on %s" % (sequence, prog, db)) b = BlastRun.objects.get(id=blastrunid) try: fasta_io = StringIO(sequence) records = list(SeqIO.parse(fasta_io, "fasta")) if len(records) == 1: galaxycon = galaxy_connection() galaxycon.nocache = True history = galaxycon.histories.create_history(name="BlastXplorer") b.history = history.get("id") b.query_id = biofile.cleanseqname(records[0].id) b.query_seq = records[0].seq b.evalue = evalue b.coverage = coverage b.database = db b.blastprog = prog b.maxseqs = maxseqs b.status = BlastRun.PENDING b.save() blast_type = BlastRun.blast_type(BlastRun.PASTEUR, prog) blast_inputtype = BlastRun.blast_inputtype(BlastRun.PASTEUR, prog) # We check alphabet of given sequence if ((blast_inputtype == "nt" and not biofile.check_nt(b.query_seq)) or (blast_inputtype == "aa" and not biofile.check_aa(b.query_seq))): b.status = BlastRun.ERROR b.message = "The given sequence has the wrong alphabet. Program %s expects %s sequence" % ( blast_type, blast_inputtype) elif blast_type is not None: tmp_file = tempfile.NamedTemporaryFile() tmp_file.write(sequence) tmp_file.flush() if biofile.is_fasta_one_seq(tmp_file.name): ## Upload input query file to galaxy outputs = galaxycon.tools.upload_file( path=tmp_file.name, file_name="blastinput.fasta", history_id=history.get("id"), file_type="fasta") file_id = outputs.get('outputs')[0].get('id') ## Configuring job tool_inputs = inputs() tool_inputs.set_dataset_param("query", file_id) tool_inputs.set_param("db_opts|database", db) tool_inputs.set_param("blast_type", blast_type) tool_inputs.set_param("evalue_cutoff", evalue) tool_inputs.set_param("output|out_format", "5") ## Running blast job outputs = galaxycon.tools.run_tool( history_id=history.get("id"), tool_id=prog, tool_inputs=tool_inputs) b.history_fileid = outputs.get("outputs")[0].get("id") else: b.status = BlastRun.ERROR b.message = "Bad input FASTA file format" else: b.status = BlastRun.ERROR b.message = "Wrong blast program %s" % (prog) b.save() else: b.status = BlastRun.ERROR b.message = "More than one record in the fasta file! %d" % (len( list(records))) except Exception as e: logging.exception(str(e)) b.status = BlastRun.ERROR b.message = str(e) b.save() time.sleep(30)
def tool_exec_view(request, pk, store_output=None): """ :param request: :param pk: :param store_output: :return: """ gi = request.galaxy message = "" tool_obj = get_object_or_404(Tool, pk=pk) toolfield, created = ToolFieldWhiteList.objects.get_or_create( tool=tool_obj, context='t') tool_visible_field = toolfield.saved_params tool_inputs_details = gi.tools.show_tool( tool_id=tool_obj.id_galaxy, io_details='true') tool_form = ToolForm(tool_params=tool_inputs_details['inputs'], tool_id=pk, whitelist=tool_visible_field, data=request.POST or None, session_files=request.session.get('files') ) hid = {} if request.method == 'POST': if tool_form.is_valid(): try: wksph = None tool_inputs = inputs() # mapping between form id to galaxy params names fields = tool_form.fields_ids_mapping exts = tool_form.fields_ext_mapping inputs_data = set(tool_form.input_file_ids) nboot = 0 boot = False for key, value in request.POST.items(): if not key in inputs_data: if fields.get(key,"") == 'bootstrap|replicates': nboot = value if (fields.get(key,"") == 'bootstrap|do_bootstrap' and value == 'true' or fields.get(key,"") == 'bootstrap|support' and (value == 'boot' or value == '1')): boot = True tool_inputs.set_param(fields.get(key), value) if not boot: nboot = 0 for inputfile in inputs_data: outputs = "" uploaded_file = "" if request.FILES: uploaded_file = request.FILES.get(inputfile, '') tmp_file = tempfile.NamedTemporaryFile() if uploaded_file: for chunk in uploaded_file.chunks(): tmp_file.write(chunk) tmp_file.flush() # send file to galaxy after verifying the # allowed extensions type = biofile.detect_type(tmp_file.name) nseq, length, seqaa = biofile.nb_sequences(tmp_file.name, type) if type in ["fasta", "phylip"] and nseq <= 3: msg='Input Sequence file should contain more than 3 sequences for field %s' % ( fields.get(inputfile)) raise ValueError(msg) if type in ["fasta", "phylip"] and not tool_obj.can_run_on_data(nseq, length, nboot, seqaa): raise ValueError('Given data is too large to run with this tool') if type in exts.get(inputfile, ""): if wksph is None: wksph = create_history(request, name="Analyse with " + tool_obj.name, wf_category="Tool", wf_steps=tool_obj.name) outputs = gi.tools.upload_file(path=tmp_file.name, file_name=uploaded_file.name, history_id=wksph.history, file_type=type) else: raise ValueError('File format of file %s is not allowed for field %s' % ( uploaded_file.name, fields.get(inputfile))) else: # else paste content content = request.POST.get(inputfile) galaxyfile = request.POST.get( "galaxyfile_" + inputfile) if content: tmp_file = tempfile.NamedTemporaryFile() tmp_file.write(content) tmp_file.flush() # send file to galaxy after verifying the # allowed extensions input_fieldname = fields.get(inputfile) type = biofile.detect_type(tmp_file.name) nseq, length, seqaa = biofile.nb_sequences(tmp_file.name, type) if type in ["fasta", "phylip"] and nseq <= 3: msg='Input Sequence file should contain more than 3 sequences for field %s' % ( fields.get(inputfile)) raise ValueError(msg) if type in ["fasta", "phylip"] and not tool_obj.can_run_on_data(nseq, length, nboot, seqaa): raise ValueError('Given data is too large to run with this tool') if type in exts.get(inputfile, ""): if wksph is None: wksph = create_history(request, name="Analyse with " + tool_obj.name, wf_category="Tool", wf_steps=tool_obj.name) outputs = gi.tools.upload_file(path=tmp_file.name, file_name=input_fieldname + " pasted_sequence", history_id=wksph.history, file_type=type) else: raise ValueError( 'This file format is not allowed for field %s' % (input_fieldname)) # Else we look at galaxy file ids else: if galaxyfile: file_id = galaxyfile hid[inputfile] = file_id elif inputfile == "1": # It should be the initial input file # and is required raise ValueError('No input file given') if outputs: file_id = outputs.get('outputs')[0].get('id') hid[inputfile] = file_id for h, file_id in hid.items(): tool_inputs.set_dataset_param(fields.get(h), file_id) if wksph is None: wksph = create_history(request, name="Analyse with " + tool_obj.name, wf_category="Tool", wf_steps=tool_obj.name) tool_outputs = gi.tools.run_tool(history_id=wksph.history, tool_id=tool_obj.id_galaxy, tool_inputs=tool_inputs) # Start monitoring (for sending emails) initializeworkspacejob.delay(wksph.history) wksph.monitored = True wksph.save() if store_output: request.session['output'] = tool_outputs return redirect(reverse_lazy("history_detail", kwargs={'history_id': wksph.history})) except ValueError as ve: message = str(ve) except ConnectionError as ce: message = str(ce) except NameError as ne: message = str(ne) except OperationalError as oe: message = str(oe) except AttributeError as ae: message = str(ae) except TypeError as te: message = str(te) except Exception as e: raw_message = ast.literal_eval(e) reverse_dict_field = { v: k for k, v in tool_form.fields_ids_mapping.items()} err_data = raw_message.get('err_data') if err_data: for field, err_msg in err_data.items(): tool_form.add_error(reverse_dict_field.get(field), ValidationError(err_msg, code='invalid')) else: message = raw_message delete_history(request, wksph.history) context = {"toolform": tool_form, "tool": tool_obj, "message": message} return render(request, 'tools/tool_form.html', context)
def analyze_forms(self, request, context, workflow, params, gi, wksph): steps = workflow.json['steps'] step_id = u'0' for tool_form in context['form_list']: if not tool_form.is_valid(): raise WorkflowInvalidFormError( "One form is invalid %s " % (tool_form.prefix)) tool_inputs = inputs() # mapping between form id to galaxy params names fields = tool_form.fields_ids_mapping inputs_data = set(tool_form.input_file_ids) # set the Galaxy parameter (name, value) for key, value in tool_form.cleaned_data.items(): if key not in inputs_data: tool_inputs.set_param(fields.get(key), value) for inputfile in inputs_data: uploaded_file = "" if request.FILES: uploaded_file = request.FILES.get(inputfile, '') if uploaded_file: tmp_file = tempfile.NamedTemporaryFile() for chunk in uploaded_file.chunks(): tmp_file.write(chunk) tmp_file.flush() # send file to galaxy outputs = gi.tools.upload_file( path=tmp_file.name, file_name=uploaded_file.name, history_id=wksph.history) file_id = outputs.get('outputs')[0].get('id') tool_inputs.set_dataset_param( fields.get(inputfile), file_id) else: # else paste content content = tool_form.cleaned_data.get(inputfile) if content: tmp_file = tempfile.NamedTemporaryFile() tmp_file.write(content) tmp_file.flush() # send file to galaxy input_fieldname = tool_form.fields_ids_mapping.get( inputfile) outputs = gi.tools.upload_file( path=tmp_file.name, file_name=input_fieldname + " pasted_sequence", history_id=wksph.history) file_id = outputs.get('outputs')[0].get('id') tool_inputs.set_dataset_param(fields.get(inputfile), file_id) # workflow step # get from which step the tools are used for i, step in steps.items(): if (getattr(tool_form, 'tool_id', 'null') == step.get('tool_id')): step_id = i break # convert inputs to dict params[step_id] = tool_inputs.to_dict() if not params[step_id]: del params[step_id]
def make_inputs(input_params): ''' input builder''' tool_inputs = inputs() for i in input_params: tool_inputs = tool_inputs.set(i, input_params[i]) return tool_inputs