def _getInterconversionEnergy(self, request, uri, interconversion_uuid):
graph = graphstore.graph()
try:
route = grrm2.Interconversion.get(
graph, utils.uuidToUri(interconversion_uuid))
except:
raise http.Http404
output = {}
start = grrm2.interconversionStart(route).get()[0]
end = grrm2.interconversionEnd(route).get()[0]
energies = {}
for step in grrm2.interconversionStep(route).getAll():
step = step[0]
energies[grrm2.stepNumber(step).get()] = grrm2.energy(step).get()
energies[0] = grrm2.energy(start).get()
energies[max(energies.keys()) + 1] = grrm2.energy(end).get()
output["energies"] = energies
return http.HttpResponse(simplejson.dumps(output),
mimetype='application/javascript')
def dispatch(self, request, **args):
graph = graphstore.graph()
try:
run = grrm2.Run.get(graph, args["uri"])
except:
return None
return { "resource_uuid" : utils.uriToUuid(run.uri())}
def _getTableData(self,request,uri):
try:
uris = request.GET.getlist("uris")
# page = int(request.POST['page'])
# rows_per_page = int(request.POST['rp'])
# sortname = request.POST['sortname']
# sortorder = request.POST['sortorder']
except:
return http.HttpResponseBadRequest()
json_response = {}
json_response["rows"] = []
for uri in uris:
resclass = ordfm.classByUri(graphstore.graph(),uri)
resource = resclass.get(graphstore.graph(),uri)
storage = filestorage.ResourceStorage(resource, web_accessible=True, settings=settings.filestorage_settings)
iconstorage = filestorage.ResourceIcon(resource, settings=settings.filestorage_settings)
row = {}
row["icon"] = iconstorage.url(filestorage.ResourceIcon.STATIC)
row["animatedicon"] = iconstorage.url(filestorage.ResourceIcon.ANIMATED)
row["uri"] = uri
row["url"] = utils.resourceUrl(resource)
row["type"] = resclass.visibleName()
json_response["rows"].append(row)
# if page < 0:
# return http.HttpResponseBadRequest("Invalid page number")
#
# graph = graphstore.graph()
# c = ordfm.Collection.get(graph, uri)
#
# json_response = { "page": page,
# "total": len(c.contents()),
# "rows" : []
# }
#
# for m_uri in c.contents().values()[(page-1)*rows_per_page:(page-1)*rows_per_page+rows_per_page]:
# m = ordfm.Molecule.get(graph, m_uri)
# json_response["rows"].append( { "cell" : [ "<span style=\"font-family: Courier\"><a href=\"/molecules/{"+utils.uriToUuid(m_uri)+"}\">"+utils.uriToUuid(m_uri)+"</a></span>", "", m.formula(), str(m.structureType()), str(m.energy()) ] } )
return http.HttpResponse(simplejson.dumps(json_response), mimetype='application/javascript')
def render(request, resource_uuid):
log = logger.logger("wavemoldb.api")
try:
resource_uri = utils.uuidToUri(resource_uuid)
except:
log.info("Invalid resource uuid "+str(resource_uuid))
raise http.Http404
g=rdflib.ConjunctiveGraph()
for p,o in graphstore.graph().predicate_objects(rdflib.URIRef(resource_uri)):
if type(o) == rdflib.BNode:
dumpBNode(graphstore.graph(), o, g)
g.add( (rdflib.URIRef(resource_uri),p,o) )
for s,p in graphstore.graph().subject_predicates(rdflib.URIRef(resource_uri)):
if type(s) == rdflib.BNode:
dumpBNode(graphstore.graph(), s, g)
g.add( (s, p, rdflib.URIRef(resource_uri)) )
response = http.HttpResponse(g.serialize(), mimetype="text/xml")
return response
def dispatch(self, request, uri):
context = {}
graph = graphstore.graph()
try:
molecule = grrm2.Molecule.get(graph, uri)
except:
return None
if grrm2.fragments(molecule).get() is None:
return None
context["fragmentInfo"] = []
fragments = grrm2.fragments(molecule).get()
geometry = grrm2.geometry(molecule).get()
canost_planar = grrm2.fragmentsCanostPlanar(molecule).get()
canost_serial = grrm2.fragmentsCanostSerial(molecule).get()
canost_planar_canonical = grrm2.fragmentsCanostPlanarCanonical(
molecule).get()
canost_serial_canonical = grrm2.fragmentsCanostSerialCanonical(
molecule).get()
for i, frag in enumerate(fragments):
fragment_info = {}
fragment_info["index"] = i
fragment_info["atomIndices"] = str(frag)
symbols = [geometry["symbols"][j - 1] for j in frag]
fragment_info["hillFormula"] = str(chemistry.hillFormula(symbols))
try:
fragment_info["canostPlanar"] = "|".join(canost_planar[i])
except:
fragment_info["canostPlanar"] = None
try:
fragment_info["canostSerial"] = "|".join(canost_serial[i])
except:
fragment_info["canostSerial"] = None
try:
fragment_info[
"canostPlanarCanonical"] = canost_planar_canonical[i]
except:
fragment_info["canostPlanarCanonical"] = None
try:
fragment_info[
"canostSerialCanonical"] = canost_serial_canonical[i]
except:
fragment_info["canostSerialCanonical"] = None
context["fragmentInfo"].append(fragment_info)
return context
def dispatch(self, request, **args):
current_uri = args["uri"]
graph = graphstore.graph()
try:
iconv = grrm2.Interconversion.get(graph, current_uri)
except:
return None
ctx = {}
ctx["steps"] = []
ctx["start"] = ResultInfo()
ctx["end"] = ResultInfo()
start = grrm2.interconversionStart(iconv).get()[0]
ctx["start"].uri = start.uri()
ctx["start"].link = "/resources/%7B" + utils.uriToUuid(
start.uri()) + "%7D"
iconstorage = filestorage.ResourceIcon(
start, settings=settings.filestorage_settings)
ctx["start"].icon = iconstorage.url(filestorage.ResourceIcon.STATIC)
ctx["start"].energy = grrm2.energy(start).get()
ctx["start"].label = _getLabel(start)
end = grrm2.interconversionEnd(iconv).get()[0]
ctx["end"].uri = end.uri()
ctx["end"].link = "/resources/%7B" + utils.uriToUuid(end.uri()) + "%7D"
iconstorage = filestorage.ResourceIcon(
end, settings=settings.filestorage_settings)
ctx["end"].icon = iconstorage.url(filestorage.ResourceIcon.STATIC)
ctx["end"].energy = grrm2.energy(end).get()
ctx["end"].label = _getLabel(end)
for s in grrm2.interconversionStep(iconv).getAll():
step = s[0]
iconstorage = filestorage.ResourceIcon(
step, settings=settings.filestorage_settings)
info = StepInfo()
info.link = "/resources/%7B" + utils.uriToUuid(step.uri()) + "%7D"
info.icon = iconstorage.url(filestorage.ResourceIcon.STATIC)
info.uri = step.uri()
info.energy = grrm2.energy(step).get()
info.number = grrm2.stepNumber(step).get()
ctx["steps"].append(info)
def cmpFunc(x, y):
return cmp(x.number, y.number)
ctx["steps"] = sorted(ctx["steps"], cmp=cmpFunc)
return ctx
def dispatch(self, request, **args):
current_uri = args["uri"]
graph = graphstore.graph()
try:
route = grrm2.Interconversion.get(graph, current_uri)
except:
return None
start = grrm2.interconversionStart(route).get()[0]
end = grrm2.interconversionEnd(route).get()[0]
iconstorage_start = filestorage.ResourceIcon(start, settings=settings.filestorage_settings)
iconstorage_end = filestorage.ResourceIcon(end, settings=settings.filestorage_settings)
iconstorage_route = filestorage.ResourceIcon(route, settings=settings.filestorage_settings)
ctx = {}
ctx["startUrl"] = "/resources/%7B"+utils.uriToUuid(start.uri())+"%7D"
ctx["endUrl"] = "/resources/%7B"+utils.uriToUuid(end.uri())+"%7D"
ctx["startIcon"] = iconstorage_start.url(filestorage.ResourceIcon.STATIC)
ctx["endIcon"] = iconstorage_end.url(filestorage.ResourceIcon.STATIC)
ctx["connectionRouteIcon"] = iconstorage_route.url(filestorage.ResourceIcon.ANIMATED)
ctx["startStructureLabel"] = _getLabel(start)
ctx["endStructureLabel"] = _getLabel(end)
energies = {}
for step in grrm2.interconversionStep(route).getAll():
step = step[0]
energies[grrm2.stepNumber(step).get()] = grrm2.energy(step).get()
energies[0] = grrm2.energy(start).get()
energies[max(energies.keys())+1] = grrm2.energy(end).get()
chart_query = http.QueryDict("").copy()
chart_query.update( {
"cht": "lxy",
"chs": "400x400",
"chd": "t:"+",".join([ str(x) for x in energies.keys()])+"|"+",".join( [str(x) for x in energies.values()]),
"chds": str(min(energies.keys()))+","+str(max(energies.keys()))+","+str(min(energies.values()))+","+str(max(energies.values())),
"chco": "3072F3,ff0000,00aaaa",
"chls": "2,4,1",
"chf": "bg,s,F0F0FF",
"chm": "s,FF0000,0,-1,5|s,0000ff,1,-1,5|s,00aa00,2,-1,5",
"chxt": "x,y",
"chxr": "0,"+str(min(energies.keys()))+","+str(max(energies.keys()))+"|1,"+str(min(energies.values()))+","+str(max(energies.values())),
} )
ctx["chartUrl"] = "http://chart.apis.google.com/chart?"+chart_query.urlencode()
return ctx
def dispatch(self, request, **args):
graph = graphstore.graph()
try:
run = grrm2.Run.get(graph, args["uri"])
except:
return None
storage = filestorage.ResourceStorage(
run, web_accessible=True, settings=settings.filestorage_settings)
return {
"connectivityUrl":
settings.HOST_BASE + storage.url("connectivity", "csv"),
"resource_uuid":
utils.uriToUuid(run.uri())
}
def dispatch(self, request, uri):
context = {}
graph = graphstore.graph()
try:
molecule = grrm2.Molecule.get(graph, uri)
except:
return None
context["moleculeInfo"] = self._getMoleculeInfo(molecule)
if context["moleculeInfo"].isInterconversionStep:
interconversion_step = grrm2.InterconversionStep.tryCast(molecule)
prev_step = grrm2.prevInterconversionStep(
interconversion_step).get()
next_step = grrm2.nextInterconversionStep(
interconversion_step).get()
interconversion = grrm2.interconversionStepOf(
interconversion_step).get()
if interconversion and interconversion[0]:
start_structure = grrm2.interconversionStart(
interconversion[0]).get()
if start_structure and start_structure[0]:
start_structure = start_structure[0]
end_structure = grrm2.interconversionEnd(
interconversion[0]).get()
if end_structure and end_structure[0]:
end_structure = end_structure[0]
if prev_step and prev_step[0]:
context["prevStepInfo"] = self._getMoleculeInfo(prev_step[0])
else:
context["prevStepInfo"] = self._getMoleculeInfo(
start_structure)
if next_step and next_step[0]:
context["nextStepInfo"] = self._getMoleculeInfo(next_step[0])
else:
context["nextStepInfo"] = self._getMoleculeInfo(end_structure)
else:
context["isInterconversion"] = False
context["fromRoutes"] = self._getFromRoutesContext(molecule)
context["toRoutes"] = self._getToRoutesContext(molecule)
return context
def _getUris(self, request, uri):
graph = graphstore.graph()
try:
run = grrm2.Run.get(graph, uri)
except:
raise http.Http404
try:
offset = int(request.GET["offset"])
except:
offset = 0
try:
limit = int(request.GET["limit"])
except:
limit = 10
output={}
output["uri_list"] = []
output["resource_type"] = []
output["total"] = len(grrm2.runOutput(run).get())
output["offset"] = offset
output["limit"] = limit
for output_tuple in grrm2.runOutput(run).get().limit(limit).offset(offset):
resource = output_tuple[0]
output["uri_list"].append(resource.uri())
if grrm2.TransitionState.tryCast(resource):
resource_type = "TransitionState"
elif grrm2.EquilibriumStructure.tryCast(resource):
resource_type = "EquilibriumStructure"
elif grrm2.EquilibriumStructure.tryCast(resource):
resource_type = "EquilibriumStructure"
elif grrm2.BarrierDissociated.tryCast(resource):
resource_type = "BarrierDissociated"
elif grrm2.BarrierlessDissociated.tryCast(resource):
resource_type = "BarrierlessDissociated"
elif grrm2.Interconversion.tryCast(resource):
resource_type = "Interconversion"
elif grrm2.InterconversionStep.tryCast(resource):
resource_type = "InterconversionStep"
else:
resource_type = "Thing"
output["resource_type"].append(resource_type)
return http.HttpResponse(simplejson.dumps(output), mimetype='application/javascript')
def dispatch(self, request, **args):
graph = graphstore.graph()
try:
run = grrm2.Run.get(graph, args["uri"])
except:
return None
return_dict = { "input" : [],
"output": [],
}
for input_tuple in grrm2.runInput(run).getAll():
resource = input_tuple[0]
input = {}
return_dict["input"].append(input)
input["uuid"] = utils.uriToUuid(resource.uri())
input["data"] = {}
run_data = grrm2.RunData.tryCast(resource)
if run_data:
input["data"]["Type"] = "RunData"
input["data"]["Basis set"] = grrm2.basisSet(run_data).get()
input["data"]["Method"] = grrm2.method(run_data).get()
input["data"]["Job"] = grrm2.job(run_data).get()
continue
molecule= grrm2.Molecule.tryCast(resource)
if molecule:
input["url"] = "/resources/%7B"+input["uuid"]+"%7D"
input["data"]["Type"] = "Molecule"
input["data"]["Hill Formula"] = grrm2.hillFormula(molecule).get()
input["data"]["Mass"] = grrm2.mass(molecule).get()
input["data"]["SMILES"] = grrm2.smiles(molecule).get()
input["data"]["InChi"] = grrm2.inchi(molecule).get()
input["data"]["Spin Multiplicity"] = grrm2.spinMultiplicity(molecule).get()
continue
input["data"]["Type"] = "Unknown"
return return_dict
def dispatch(self, request, uri):
context = {}
graph = graphstore.graph()
try:
molecule = grrm2.Molecule.get(graph, uri)
except:
molecule = None
if not molecule:
return None
fs = filestorage.ResourceStorage(
molecule,
web_accessible=True,
settings=settings.filestorage_settings)
context["xyzFilePath"] = fs.url("geometry", "xyz")
if not fs.readable("geometry", "xyz"):
context = None
return context
def _get_id(submission):
storage = filestorage.ResourceStorage(submission, web_accessible=False, settings=settings.filestorage_settings)
f=file(storage.path("system","uuid"), "r")
id = str(uuid.UUID(f.readlines()[0]))
f.close()
return id
base_graph = None
submission_info_subgraph = None
try:
options = Options(sys.argv)
base_graph = graphstore.graph()
submission_info_subgraph = ContextGraph(base_graph.store, identifier=contexts.CONTEXT_NS.SubmissionInfo)
submission = ordfm.OriginalSubmission.get(submission_info_subgraph,uri="urn:uuid:"+options.submission_uuid)
if submission is None:
_usage("unexistent submission")
sys.exit(1)
try:
id = _get_id(submission)
except:
id = _generate_id(submission)
print id
except Exception, e:
def dispatch(self, request, uri):
context = {}
graph = graphstore.graph()
try:
molecule = grrm2.Molecule.get(graph, uri)
except:
return None
context["moleculeInfo"] = []
context["moleculeInfo"].append(
("Formula", grrm2.hillFormula(molecule).get(), None))
context["moleculeInfo"].append(
("Molecular Mass", grrm2.mass(molecule).get(), None))
context["moleculeInfo"].append(
("InChi", grrm2.inchi(molecule).get(), None))
context["moleculeInfo"].append(
("SMILES", grrm2.smiles(molecule).get(), None))
context["moleculeInfo"].append(
("Energy", grrm2.energy(molecule).get(), None))
context["moleculeInfo"].append(
("Charge", grrm2.charge(molecule).get(), None))
context["moleculeInfo"].append(
("Spin", grrm2.spin(molecule).get(), None))
context["moleculeInfo"].append(
("Structure Type", _getStructureType(molecule), None))
result = grrm2.InterconversionResult.tryCast(molecule)
if result:
context["moleculeInfo"].append(
("Structure Number", grrm2.structureNumber(result).get(),
None))
context["moleculeInfo"].append(
("Zero Point Vibrational Energy",
grrm2.zeroPointVibrationalEnergy(result).get(), None))
step = grrm2.InterconversionStep.tryCast(molecule)
if step:
context["moleculeInfo"].append(
("Interconversion Step", grrm2.stepNumber(step).get(), None))
context["moleculeInfo"].append(
("Belongs to interconversion",
grrm2.interconversionStepOf(step).get()[0].uri(),
"/resources/%7B" + utils.uriToUuid(
grrm2.interconversionStepOf(step).get()[0].uri()) +
"%7D"))
context["moleculeInfo"].append(
("CANOST canonical planar",
grrm2.canostSerialCanonical(molecule).get(), None))
context["moleculeInfo"].append(
("CANOST canonical serial",
grrm2.canostPlanarCanonical(molecule).get(), None))
context["moleculeInfo"].append(
("CANOST planar codes", grrm2.canostPlanar(molecule).get(), None))
context["moleculeInfo"].append(
("CANOST serial codes", grrm2.canostSerial(molecule).get(), None))
fragment_strings = []
if grrm2.fragments(molecule).get() is not None:
geometry = grrm2.geometry(molecule).get()
for fragment in grrm2.fragments(molecule).get():
symbols = [geometry["symbols"][i - 1] for i in fragment]
fragment_strings.append(chemistry.hillFormula(symbols))
context["moleculeInfo"].append(
("Fragments", "/".join(fragment_strings), None))
try:
run = grrm2.runOutputOf(molecule).get()[0]
context["moleculeInfo"].append(
("Run", run.uri(),
"/resources/%7B" + utils.uriToUuid(run.uri()) + "%7D"))
except Exception, e:
pass
def main():
options=Options(sys.argv)
system_uuid = helperfuncs.getSystemUuid(graphstore.store(), options.submission_uuid)
submission_info_subgraph = Graph(graphstore.store(), identifier=contexts.CONTEXT_NS.SubmissionInfo)
submission = ordfm.SystemSubmission.get(submission_info_subgraph,uri="urn:uuid:"+str(system_uuid))
if submission is None:
submission = ordfm.SystemSubmission.new(submission_info_subgraph,uri="urn:uuid:"+str(system_uuid))
submission_info_subgraph.commit()
else:
print "Previous submission found. overwriting"
graphstore.graph().remove_context(rdflib.URIRef("urn:uuid:"+str(system_uuid)))
graphstore.graph().commit()
graph = Graph(graphstore.store(), identifier=rdflib.URIRef("urn:uuid:"+str(options.submission_uuid)))
system_graph = Graph(graphstore.store(), identifier=rdflib.URIRef("urn:uuid:"+str(system_uuid)))
print "Adding to graph id urn:uuid:"+str(system_uuid)
for mol in grrm2.Molecule.all(graph):
print "-"*40
print "molecule "+str(mol.uri())
m = grrm2.Molecule.new(system_graph, mol.uri())
formula = helperfuncs.generateFormula(mol)
inchi = helperfuncs.generateInchi(mol)
smiles = helperfuncs.generateSmiles(mol)
mass = helperfuncs.generateMass(mol)
print "Formula: "+str(formula)
print "Inchi: "+str(inchi)
print "Smiles: "+str(smiles)
print "Mass: "+str(mass)
if formula is not None:
grrm2.hillFormula(m).set(formula)
if inchi is not None:
grrm2.inchi(m).set(inchi)
if smiles is not None:
grrm2.smiles(m).set(smiles)
if mass is not None:
grrm2.mass(m).set(mass)
try:
helperfuncs.generateMdl(mol)
except:
pass
canost_planar = helperfuncs.generateCanostPlanar(mol)
canost_serial = helperfuncs.generateCanostSerial(mol)
canost_canonical = helperfuncs.generateCanostCanonical(mol)
print "canost planar: "+str(canost_planar)
print "canost serial: "+str(canost_serial)
print "canost canonical: "+str(canost_canonical)
if canost_planar is not None:
grrm2.canostPlanar(m).set(canost_planar)
if canost_serial is not None:
grrm2.canostSerial(m).set(canost_serial)
if canost_canonical is not None:
canost_planar_canonical, canost_serial_canonical = canost_canonical
if canost_planar_canonical is not None:
grrm2.canostPlanarCanonical(m).set(canost_planar_canonical)
if canost_serial_canonical is not None:
grrm2.canostSerialCanonical(m).set(canost_serial_canonical)
try:
helperfuncs.generateMdlForFragments(mol)
except:
pass
canost_planar_fragments = helperfuncs.generateCanostPlanarFragments(mol)
print "canost planar fragments: "+str(canost_planar_fragments)
if canost_planar_fragments is not None:
grrm2.fragmentsCanostPlanar(m).set(canost_planar_fragments)
canost_serial_fragments = helperfuncs.generateCanostSerialFragments(mol)
print "canost serial fragments: "+str(canost_serial_fragments)
if canost_serial_fragments is not None:
grrm2.fragmentsCanostSerial(m).set(canost_serial_fragments)
canost_canonical_fragments = helperfuncs.generateCanostCanonicalFragments(mol)
print "canost canonical fragments: "+str(canost_canonical_fragments)
if canost_canonical_fragments is not None:
canost_planar_canonical_fragments=[]
canost_serial_canonical_fragments=[]
for fragment_result in canost_canonical_fragments:
if fragment_result is None:
canost_planar_canonical_fragments.append(None)
canost_serial_canonical_fragments.append(None)
continue
canost_planar_canonical_fragments.append(fragment_result[0])
canost_serial_canonical_fragments.append(fragment_result[1])
print "canost_planar_canonical_fragments : "+str(canost_planar_canonical_fragments)
print "canost_serial_canonical_fragments : "+str(canost_serial_canonical_fragments)
grrm2.fragmentsCanostPlanarCanonical(m).set(canost_planar_canonical_fragments)
grrm2.fragmentsCanostSerialCanonical(m).set(canost_serial_canonical_fragments)
system_graph.commit()
m=grrm2.Run.get(graph,res[0])
if m:
indexer.store(res[0], { "is_grrm__run" : True})
except:
pass
def _indexEnergy(graph, indexer):
indexer.addIndex("grrm__energy", "VARCHAR(255)")
for m in grrm2.Molecule.all(graph):
energy = grrm2.energy(m).get()
if energy:
indexer.store(m.uri(), { "grrm__energy" : float(energy)})
try:
graph = graphstore.graph()
indexer = indexing.DbIndex()
indexer.drop()
_indexRdfType(graph, indexer)
_indexEnergy(graph, indexer)
except Exception, e:
print e
sys.exit(1)
sys.exit(0)
def dispatch(self, request, **args):
current_uri = args["uri"]
graph = graphstore.graph()
try:
transition_state = grrm2.TransitionState.get(graph, current_uri)
except:
return None
ctx = {}
iconv_start_tuple_list = grrm2.interconversionStartOf(
transition_state).getAll() or []
iconv_end_tuple_list = grrm2.interconversionEndOf(
transition_state).getAll() or []
if len(iconv_start_tuple_list) + len(iconv_end_tuple_list) != 2:
return None # we have a problem... a transition state must have two links
if len(iconv_start_tuple_list) == 2:
iconv_left = iconv_start_tuple_list[0][0]
iconv_right = iconv_start_tuple_list[1][0]
energies_left = _getEnergies(iconv_left)
energies_right = _getEnergies(iconv_right)
energies = {}
energies[0] = grrm2.energy(transition_state).get()
for k, v in sorted(map(lambda x:
(-x[0], x[1]), energies_left.items()) +
energies_right.items(),
key=lambda x: x[0]):
print k
energies[k] = v
end_left = grrm2.interconversionEnd(iconv_left).get()[0]
end_right = grrm2.interconversionEnd(iconv_right).get()[0]
energies[min(energies.keys()) - 1] = grrm2.energy(end_left).get()
energies[max(energies.keys()) + 1] = grrm2.energy(end_right).get()
else:
return None
chart_query = http.QueryDict("").copy()
chart_query.update({
"cht":
"lxy",
"chs":
"400x400",
"chd":
"t:" + ",".join([
str(x[0]) for x in sorted(energies.items(), key=lambda x: x[0])
]) + "|" + ",".join([
str(x[1]) for x in sorted(energies.items(), key=lambda x: x[0])
]),
"chds":
str(min(energies.keys())) + "," + str(max(energies.keys())) + "," +
str(min(energies.values())) + "," + str(max(energies.values())),
"chco":
"3072F3,ff0000,00aaaa",
"chls":
"2,4,1",
"chf":
"bg,s,F0F0FF",
"chm":
"s,FF0000,0,-1,5|s,0000ff,1,-1,5|s,00aa00,2,-1,5",
"chxt":
"x,y",
"chxr":
"0," + str(min(energies.keys())) + "," +
str(max(energies.keys())) + "|1," + str(min(energies.values())) +
"," + str(max(energies.values())),
})
ctx["chartUrl"] = "http://chart.apis.google.com/chart?" + chart_query.urlencode(
)
iconstorage = filestorage.ResourceIcon(
transition_state, settings=settings.filestorage_settings)
if iconstorage.readable(filestorage.ResourceIcon.STATIC):
icon_url = iconstorage.url(filestorage.ResourceIcon.STATIC)
elif iconstorage.readable(filestorage.ResourceIcon.ANIMATED):
icon_url = iconstorage.url(filestorage.ResourceIcon.ANIMATED)
else:
icon_url = None
ctx["transitionStateIcon"] = icon_url
iconstorage = filestorage.ResourceIcon(
end_left, settings=settings.filestorage_settings)
if iconstorage.readable(filestorage.ResourceIcon.STATIC):
icon_url = iconstorage.url(filestorage.ResourceIcon.STATIC)
elif iconstorage.readable(filestorage.ResourceIcon.ANIMATED):
icon_url = iconstorage.url(filestorage.ResourceIcon.ANIMATED)
else:
icon_url = None
ctx["leftEndIcon"] = icon_url
iconstorage = filestorage.ResourceIcon(
end_right, settings=settings.filestorage_settings)
if iconstorage.readable(filestorage.ResourceIcon.STATIC):
icon_url = iconstorage.url(filestorage.ResourceIcon.STATIC)
elif iconstorage.readable(filestorage.ResourceIcon.ANIMATED):
icon_url = iconstorage.url(filestorage.ResourceIcon.ANIMATED)
else:
icon_url = None
ctx["rightEndIcon"] = icon_url
ctx["leftEndUrl"] = "/resources/%7B" + utils.uriToUuid(
end_left.uri()) + "%7D"
ctx["rightEndUrl"] = "/resources/%7B" + utils.uriToUuid(
end_right.uri()) + "%7D"
return ctx
