def add_pdb_files(request, dataset_id):
"""
Extracts pdb files out of zips, adds them to the dataset and
removes the zip. Then adds all pdb files to the MR parameters
:param dataset_id: dataset in which to find zip files
:type dataset_id: integer
:returns: 'true' for ajax if successful.
"""
thisMR = MRtask(dataset_id=dataset_id)
thisMR.add_pdb_files(request.user.username)
return HttpResponse("true")
def parseMTZfile(request, dataset_id):
"""
parse MTZ file to extract metadata
:param dataset_id: dataset_id in which to look for MTZ file
:type dataset_id: integer
:returns: "true" or 404
"""
thisMR = MRtask(dataset_id=dataset_id)
if thisMR.add_mtz_file():
return HttpResponse("true")
else:
return HttpResponseNotFound()
def deleteFile(request, dataset_id):
"""
delete a file completely, totally and utterly
:returns: true or 404
"""
if request.POST and "file_id" in request.POST:
file_id = request.POST["file_id"]
thisfile = Dataset_File.objects.get(pk=file_id)
thisMR = MRtask(dataset_id=dataset_id)
par = thisMR.get_by_value(thisfile.filename)
print par
if par != None:
par.delete()
thisfile.deleteCompletely()
return HttpResponse("true")
return HttpResponseNotFound()
def runningJobs(request, experiment_id):
MRlist = [thistask for thistask in MRtask.getTaskList(experiment_id, status="running")]
if "check" in request.POST and request.POST["check"] == "yesplease":
for task in MRlist:
task.check_status_on_hpc()
jobs = [(jobs.dataset, jobs.get_params("jobid", value=True)) for jobs in MRlist]
c = Context({"experiment_id": experiment_id, "jobs": jobs})
return render_to_response("mrtardis/joblist.html", c)
def displayResults(request, experiment_id):
"""
display results of POST submitted dataset in experiment_id
:param experiment_id: experiment id containing results
:type experiment_id: integer
:returns: mrtardis/displayResults.html
"""
if "dataset" in request.POST:
thisMR = MRtask(dataset_id=request.POST["dataset"])
else:
return HttpResponseNotFound()
results = thisMR.parseResults()
c = Context(
{
"dataset": thisMR.dataset,
"results": results,
"experiment_id": experiment_id,
"f_value": thisMR.get_param("f_value", value=True),
"sigf_value": thisMR.get_param("sigf_value", value=True),
"mol_weight": thisMR.get_param("mol_weight", value=True),
"num_in_asym": thisMR.get_param("num_in_asym", value=True),
"packing": thisMR.get_param("packing", value=True),
"ensemble_number": thisMR.get_param("ensemble_number", value=True),
}
)
return render_to_response("mrtardis/displayResults.html", c)
def jobfinished(request, dataset_id):
thisMR = MRtask(dataset_id=dataset_id)
if "jobid" not in request.GET and thisMR.get_status(value=True) != "running":
return HttpResponseNotFound()
jobid = request.GET["jobid"]
for jid in thisMR.get_params("jobid", value=True):
if jid == jobid:
thisMR.new_param("jobidstatus", jobid + "-finished")
if thisMR.retrievalTrigger():
hpcusers = HPCUser.objects.filter(hpc_username=thisMR.get_param("hpc_username", value=True))
for hpcuser in hpcusers:
if hpcuser.user.email != "":
thisMR.sendMail(hpcuser.user.get_full_name(), hpcuser.user.email, request.build_absolute_uri("/"))
return HttpResponse("true")
def runMR(request, dataset_id):
"""
runs molecular replacement if all inputs are complete
:param dataset_id: id of dataset to process
:type dataset_id: integer
:returns: run status in template mrtardis/running.html
"""
print "runMR"
thisMR = MRtask(dataset_id=dataset_id)
jobids = thisMR.run(request)
experiment_id = Dataset.objects.get(pk=dataset_id).experiment.id
if not jobids:
request.POST = dict()
request.POST["action"] = "continue"
request.POST["dataset"] = dataset_id
request.POST["message"] = "Some parameters are missing"
return access_error_avoider_function(request, dataset_id)
# experiment_id = Dataset.objects.get(pk=dataset_id).experiment.id
# return MRform(request, experiment_id)
c = Context({"jobids": jobids, "experiment_id": experiment_id})
return render_to_response("mrtardis/running.html", c)
def MRform(request, experiment_id):
"""
setup of a new MR process overview
:param experiment_id: experiment id of current experiment
:type experiment_id: integer
:returns: overview page corresponding to dataset submitted via POST
using mrtardis/MRform.html template
"""
# logger.debug(repr(request.POST))
if "action" not in request.POST:
return HttpResponseNotFound("<h1>Wrong use of function</h1>")
action = request.POST["action"]
if action == "newDS":
newMRtask = MRtask(description=request.POST["description"], experiment_id=experiment_id)
newMRtask.set_status("unsubmitted")
dataset = newMRtask.dataset
elif action == "continue":
dataset = Dataset.objects.get(pk=int(request.POST["dataset"]))
pass # load existing parameters into form
elif action == "rerunDS":
olddataset = Dataset.objects.get(pk=request.POST["dataset"])
oldMRtask = MRtask(dataset=olddataset)
newMRtask = MRtask.clone(
oldInstance=oldMRtask, newDescription=request.POST["description"], username=request.user.username
)
newMRtask.set_status("unsubmitted")
dataset = newMRtask.dataset
pass # run new MR based on finished one
if "message" in request.POST:
message = request.POST["message"]
else:
message = ""
DSfileSelectChoices = [
(otherDataset.id, otherDataset.description)
for otherDataset in Dataset.objects.filter(experiment__pk=experiment_id)
if otherDataset.id != dataset.id
]
datasetSelectForm = selectDSForm(DSfileSelectChoices)
c = Context(
{"message": message, "dataset": dataset, "experiment_id": experiment_id, "datasetSelectForm": datasetSelectForm}
)
return render_to_response("mrtardis/MRform.html", c)
def getChoices(status):
return [
(mytask.dataset.id, mytask.dataset.description)
for mytask in MRtask.getTaskList(experiment_id, status=status)
]
def checkjobs(request, dataset_id):
thisMR = MRtask(dataset_id=dataset_id)
thisMR.check_status_on_hpc()
return HttpResponse("true")
def parForm(request, dataset_id):
"""
shows/saves django form for MR parameters
:param dataset_id: dataset to find parameters in
:type dataset_id: integer
:returns: template mrtardis/parform.html
"""
contextdict = dict()
thisMR = MRtask(dataset_id=dataset_id)
f_choices = [(x.string_value, x.string_value) for x in thisMR.get_params("f_values")]
sigf_choices = [(x.string_value, x.string_value) for x in thisMR.get_params("sigf_values")]
try:
sg_num = int(thisMR.get_param("spacegroup_mtz").string_value)
except ObjectDoesNotExist:
sg_num = None
formerrors = None
rmsderrors = None
if request.method == "POST":
print request.POST
paramForm = ParamForm(f_choices, sigf_choices, sg_num, request.POST)
rmsd_formfactory = formset_factory(RmsdForm)
rmsdForms = rmsd_formfactory(request.POST)
# print rmsdForms.is_valid()
# print rmsdForms.errors
# print paramForm.is_valid()
# print paramForm.errors
if paramForm.is_valid() and rmsdForms.is_valid():
# print "is validated"
thisMR.set_params_from_dict(paramForm.cleaned_data)
thisMR.delete_params("rmsd")
# print rmsdForms.cleaned_data
thisMR.set_param_list(
"rmsd",
[
r.cleaned_data["rmsd"]
for r in rmsdForms.forms
if "rmsd" in r.cleaned_data and r.cleaned_data["rmsd"]
],
)
# print thisMR.get_params("rmsd")
contextdict["saved"] = "Saved successfully"
else:
if paramForm.errors:
formerrors = paramForm.errors
elif rmsdForms.errors:
rmsderrors = rmsdForms.errors
formargs = thisMR.get_form_dictionary()
if len(formargs["space_group"]) == 0:
formargs["space_group"] = [sg_num]
print formargs
paramForm = ParamForm(f_choices, sigf_choices, sg_num, initial=formargs)
rmsd_pars = thisMR.get_params("rmsd")
rmsd_formfactory = formset_factory(RmsdForm, extra=1)
rmsds = [{"rmsd": r.string_value} for r in rmsd_pars]
rmsdForms = rmsd_formfactory(initial=rmsds)
contextdict["paramForm"] = paramForm
contextdict["rmsdForms"] = rmsdForms
if formerrors or rmsderrors:
contextdict["formerrors"] = formerrors
contextdict["rmsderrors"] = rmsderrors
c = Context(contextdict)
return render_to_response("mrtardis/parform.html", c)
