def make_all_static_models():
"""Write static models for all models in the database."""
# delete static model dir
try:
shutil.rmtree(static_dir)
except OSError:
pass
# make the directories
try:
makedirs(join(static_dir, 'raw'))
except OSError:
pass
failed_models = []
polisher_path = autodetect_model_polisher()
session = Session()
bigg_ids = [i[0] for i in session.query(Model.bigg_id)]
for bigg_id in bigg_ids:
if DEBUG and bigg_id != 'e_coli_core':
continue
# keep track of which models failed
print('------------------------------------------------------------\n'
'Dumping model %s' % bigg_id)
if not write_static_model(bigg_id, polisher_path):
failed_models.append(bigg_id)
session.close()
if len(failed_models) > 0:
return "Failed for models " + " ".join(failed_models)
def session(request):
"""Make a session"""
def teardown():
Session.close_all()
request.addfinalizer(teardown)
return Session()
def get(self, compartment_bigg_id):
session = Session()
result_db = (session
.query(Compartment)
.filter(Compartment.bigg_id == compartment_bigg_id)
.first())
session.close()
result = {'bigg_id': result_db.bigg_id, 'name': result_db.name}
self.return_result(result)
def get(self):
metabolite_dict = {k: float(v[0]) for k, v in
self.request.query_arguments.iteritems()}
hash = hash_metabolite_dictionary(metabolite_dict)
session = Session()
try:
results = {'results': [queries.reaction_with_hash(hash, session)],
'results_count': 1}
except NotFoundError:
results = {'results': [],
'results_count': 0}
session.close()
self.write(results)
self.finish()
def safe_query(func, *args, **kwargs):
"""Run the given function, and raise a 404 if it fails.
Arguments
---------
func: The function to run. *args and **kwargs are passed to this function.
"""
session = Session()
kwargs["session"] = session
try:
return func(*args, **kwargs)
except queries.NotFoundError as e:
raise HTTPError(status_code=404, reason=e.message)
except ValueError as e:
raise HTTPError(status_code=400, reason=e.message)
finally:
session.close()
def post(self):
query_strings = [x.strip() for x in
self.get_argument('query', '').split(',')
if x != '']
# run the queries
session = Session()
def checkbox_arg(name):
return self.get_argument(name, None) == 'on'
all_models = queries.get_model_list(session)
model_list = [m for m in all_models if checkbox_arg(m)]
include_metabolites = checkbox_arg('include_metabolites')
include_reactions = checkbox_arg('include_reactions')
include_genes = checkbox_arg('include_genes')
metabolite_results = []
reaction_results = []
gene_results = []
# genes
for query_string in query_strings:
if include_genes:
gene_results += queries.search_for_genes(query_string, session,
limit_models=model_list)
if include_reactions:
reaction_results += queries.search_for_reactions(query_string, session,
limit_models=model_list)
if include_metabolites:
metabolite_results += queries.search_for_metabolites(query_string, session,
limit_models=model_list)
result = {'results': {'reactions': reaction_results,
'metabolites': metabolite_results,
'genes': gene_results},
'no_pager': True}
session.close()
template = env.get_template("list_display.html")
self.write(template.render(result))
self.finish()
def post(self):
query_string = self.get_argument('query', '')
database_source = self.get_argument('database_source', '')
session = Session()
metabolites = queries.get_metabolites_for_database_id(session,
query_string,
database_source)
reactions = queries.get_reactions_for_database_id(session,
query_string,
database_source)
genes = queries.get_genes_for_database_id(session,
query_string,
database_source)
session.close()
dictionary = {'results': {'metabolites': metabolites,
'reactions': reactions,
'genes': genes},
'no_pager': True,
'hide_organism': True}
template = env.get_template("list_display.html")
self.write(template.render(dictionary))
self.finish()
def get(self):
# get arguments
query_string = self.get_argument("query")
page = self.get_argument('page', None)
size = self.get_argument('size', None)
search_type = self.get_argument('search_type', None)
include_link_urls = "include_link_urls" in self.request.query_arguments
# defaults
sort_column = None
sort_direction = 'ascending'
# get the sorting column
columns = _parse_col_arg(self.get_argument('columns', None))
sort_column, sort_direction = _get_col_name(self.request.query_arguments, columns,
sort_column, sort_direction)
# run the queries
session = Session()
result = None
if search_type == 'reactions':
# reactions
raw_results = queries.search_for_universal_reactions(query_string, session, page,
size, sort_column, sort_direction)
if include_link_urls:
raw_results = [dict(x, link_urls={'bigg_id': '/universal/reactions/{bigg_id}'.format(**x)})
for x in raw_results]
result = {'results': [dict(x, model_bigg_id='Universal', organism='') for x in raw_results],
'results_count': queries.search_for_universal_reactions_count(query_string,
session)}
elif search_type == 'metabolites':
raw_results = queries.search_for_universal_metabolites(query_string, session,
page, size, sort_column,
sort_direction)
if include_link_urls:
raw_results = [dict(x, link_urls={'bigg_id': '/universal/metabolites/{bigg_id}'.format(**x)})
for x in raw_results]
result = {'results': [dict(x, model_bigg_id='Universal', organism='') for x in raw_results],
'results_count': queries.search_for_universal_metabolites_count(query_string, session)}
elif search_type == 'genes':
raw_results = queries.search_for_genes(query_string, session, page,
size, sort_column,
sort_direction)
if include_link_urls:
raw_results = [dict(x, link_urls={'bigg_id': '/models/{model_bigg_id}/genes/{bigg_id}'.format(**x)})
for x in raw_results]
result = {'results': raw_results,
'results_count': queries.search_for_genes_count(query_string, session)}
elif search_type == 'models':
raw_results = queries.search_for_models(query_string, session, page,
size, sort_column, sort_direction)
if include_link_urls:
raw_results = [dict(x, link_urls={'bigg_id': '/models/{bigg_id}'.format(**x),
'metabolite_count': '/models/{bigg_id}/metabolites'.format(**x),
'reaction_count': '/models/{bigg_id}/reactions'.format(**x),
'gene_count': '/models/{bigg_id}/genes'.format(**x)})
for x in raw_results]
result = {'results': raw_results,
'results_count': queries.search_for_models_count(query_string, session)}
else:
raise HTTPError(400, 'Bad search_type %s' % search_type)
session.close()
self.write(result)
self.finish()
def get(self):
session = Session()
results = [{'bigg_id': x[0], 'name': x[1]}
for x in session.query(Compartment.bigg_id, Compartment.name)]
session.close()
self.return_result(results)