def import_sbml(input_model, sbml_file):
logging.info('parsing ChEBI')
chebi = parse_simple(get_chebi())
logging.info('reading generalized model from %s' % sbml_file)
r_id2g_id, s_id2gr_id, ub_sps = get_quotient_maps(chebi, sbml_file)
logging.info('fixing labels and compartments')
check_names(input_model)
check_compartments(input_model)
logging.info('annotating with GO')
go = parse_simple(get_go())
annotate_compartments(input_model, go)
c_id2level = comp2level(input_model, go)
c_id2info, c_id2outs = compute_c_id2info(c_id2level, input_model)
def get_r_comp(all_comp_ids):
if len(all_comp_ids) == 1:
return all_comp_ids.pop()
get_level = lambda c_id: c_id2level[c_id][0]
outer_most = min(all_comp_ids, key=get_level)
inner_most = max(all_comp_ids, key=get_level)
outer_level, inner_level = get_level(outer_most), get_level(inner_most)
if outer_level == inner_level or (outer_most
not in c_id2outs[inner_most]):
candidates = set(c_id2outs[inner_most]) & set(
c_id2outs[outer_most])
if candidates:
return max(candidates, key=get_level)
else:
return outer_most
if inner_level - outer_level > 1:
return max(c_id2outs[inner_most], key=get_level)
return outer_most
logging.info('initialising the graph')
graph = tlp.newGraph()
graph.setName(input_model.getId())
create_props(graph)
logging.info('adding species nodes')
id2n = species2nodes(graph, input_model, ub_sps)
logging.info('adding reaction nodes')
reactions2nodes(get_r_comp, graph, id2n, input_model)
# for n in (n for n in graph.getNodes() if TYPE_SPECIES == graph[TYPE][n] and graph.deg(n) > 5 \
# and not graph[ID][n] in s_id2gr_id):
# graph[UBIQUITOUS][n] = True
logging.info('duplicating nodes')
duplicate_nodes(graph)
logging.info('marking species/reaction groups')
mark_ancestors(graph, r_id2g_id, s_id2gr_id, c_id2info)
return graph, c_id2info, c_id2outs, chebi, ub_sps
def map_metabolites_compartments(model_id2dfs, chebi=None):
if not chebi:
chebi = parse_simple(get_chebi())
model_id2m_ids_groups = map_metabolites(model_id2dfs, chebi)
model_id2c_ids_groups = map_comps(model_id2dfs)
model_id2c_id2i = defaultdict(dict)
for i, model_id2c_ids in enumerate(model_id2c_ids_groups):
for model_id, c_ids in model_id2c_ids.items():
model_id2c_id2i[model_id].update({c_id: i for c_id in c_ids})
model_id2m_ids_same_comp_groups = []
for model_id2m_ids in model_id2m_ids_groups:
i2m_ids = defaultdict(list)
for model_id, m_ids in model_id2m_ids.items():
for m_id in m_ids:
df, _, _ = model_id2dfs[model_id]
c_id = df.at[m_id, 'Compartment']
if c_id in model_id2c_id2i[model_id]:
i2m_ids[model_id2c_id2i[model_id][c_id]].append((model_id, m_id))
for m_ids in i2m_ids.values():
model_id2m_ids = defaultdict(set)
if len(m_ids) > 1:
for model_id, m_id in m_ids:
model_id2m_ids[model_id].add(m_id)
if model_id2m_ids:
model_id2m_ids_same_comp_groups.append(model_id2m_ids)
return model_id2c_ids_groups, [it for it in model_id2m_ids_same_comp_groups if len(it) > 1], model_id2c_id2i
def merge_models(in_sbml_list, out_sbml):
if not in_sbml_list:
raise ValueError('Provide SBML models to be merged')
go = parse_simple(get_go())
chebi = parse_simple(get_chebi())
i = 0
model_ids = set()
go2c_id = {}
doc = libsbml.SBMLDocument(2, 4)
model = doc.createModel()
model.setId('m_merged')
m_c_ids = set()
for o_sbml in in_sbml_list:
o_doc = libsbml.SBMLReader().readSBML(o_sbml)
set_consistency_level(o_doc)
o_doc.checkL2v4Compatibility()
o_doc.setLevelAndVersion(2, 4, False, True)
o_model = o_doc.getModel()
logging.info("Processing %s" % o_sbml)
model_id = get_model_id(i, model_ids, o_model)
update_model_element_ids(model_id, o_model, go2c_id, go, chebi)
for e in o_model.getListOfCompartments():
c_id = e.getId()
if c_id not in m_c_ids:
if model.addCompartment(e):
copy_compartment(e, model)
m_c_ids.add(c_id)
for e in o_model.getListOfSpecies():
if model.getSpecies(e.getId()):
continue
if model.addSpecies(e):
copy_species(e, model)
for e in o_model.getListOfReactions():
if model.addReaction(e):
copy_reaction(e, model)
libsbml.writeSBMLToFile(doc, out_sbml)
def add_boundary_metabolites(in_sbml, out_sbml):
"""
Creates a boundary compartment with the id 'Boundary',
and transforms each input/output reaction '*_e <-> ' into '*_e <-> *_b'.
:param in_sbml: path to the SBML file with the original model
:param out_sbml: path where to store the resulting SBML file
"""
input_doc = libsbml.SBMLReader().readSBML(in_sbml)
model = input_doc.getModel()
chebi = parse_simple(get_chebi())
annotate_metabolites(model, chebi)
create_boundary_species_in_boundary_reactions(model)
libsbml.SBMLWriter().writeSBMLToFile(input_doc, out_sbml)
def combine_models(model_id2sbml, model_id2S, path):
logging.info('Going to merge models...')
chebi = parse_simple(get_chebi())
model_id2dfs = get_model_data(model_id2sbml)
model_id2c_id_groups, model_id2m_id_groups, model_id2c_id2i = \
map_metabolites_compartments(model_id2dfs, chebi=chebi)
logging.info('Mapped metabolites and compartments.')
ignore_m_ids = get_ignored_metabolites(model_id2dfs, get_proton_ch_ids())
S = join(model_id2m_id_groups, model_id2S)
ignore_m_ids |= {S.m_id2gr_id[m_id] for m_id in ignore_m_ids if m_id in S.m_id2gr_id}
merge(S, ignore_m_ids)
model_id2r_id_groups = get_r_id_groups(S)
logging.info('Mapped reactions.')
sbml = os.path.join(path, 'Merged_model.xml')
model_id2id2id, common_ids, S = simple_merge_models(S, model_id2c_id2i, model_id2dfs, sbml)
return sbml, S, model_id2id2id, common_ids, model_id2dfs, \
(model_id2c_id_groups, model_id2m_id_groups, model_id2r_id_groups)
def multimodel_pipeline(sbml2parameters, res_dir, treeefm_path, max_efm_number=1000, rewrite=True, org=None):
create_dirs(res_dir, rewrite)
get_f_path = lambda f: os.path.join('..', os.path.relpath(f, res_dir)) if f else None
tab2html = {}
model_id2sbml, model_id2S, model_id2efm_id2pws = {}, {}, {}
name2pw = get_name2pw()
pts = parse_simple(get_pts())
root_ids = {t.get_id() for t in pts.get_roots()}
chebi = parse(CHEBI)
ub_ch_ids = get_ubiquitous_chebi_ids(add_common=True, add_cofactors=True, chebi=chebi)
efm_id2pws = {}
model_id2cofactors = {}
modeld_id2m_id2chebi_id = {}
for sbml, (r_id2rev, r_id2rev_banned) in sbml2parameters.items():
doc = libsbml.SBMLReader().readSBML(sbml)
model = doc.getModel()
model_name = get_model_name(model=model)
short_model_name = model_name
if len(model_name) > 12:
short_model_name = model_name[:10].strip('-_ ')
if len(short_model_name) == 10:
short_model_name += '...'
safe_m_name = ''.join(ch for ch in short_model_name.replace(' ', '_') if ch.isalnum() or '_' == ch)
logging.info('Analysing %s...' % model_name)
# create directories to store results
logging.info("Preparing directories...")
m_dir = os.path.join(res_dir, safe_m_name)
create_dirs(m_dir, rewrite)
# exchange_rs = get_exchange_reactions(model)
# csv = '%s/%s.exchanges.csv' % (m_dir, safe_m_name)
# df2csv(reactions2df(model, exchange_rs), csv)
cofactors = select_metabolite_ids_by_term_ids(model, ub_ch_ids)
if r_id2rev:
constraint_exchange_reactions(model, forsed_r_id2rev=r_id2rev, prohibited_r_id2rev=r_id2rev_banned,
cofactors=cofactors if not r_id2rev_banned else None)
logging.info("Annotating the model...")
annotate(model, org=org, reactions=False, pathways=False, chebi=chebi)
m_id2ch_id = get_species_id2chebi_id(model)
# copy our model in the result directory
sbml = os.path.join(m_dir, '%s.constrained.xml' % safe_m_name)
libsbml.SBMLWriter().writeSBMLToFile(doc, sbml)
description = model_serializer.serialize(sbml, model, model_name, r_id2rev, m_dir, get_f_path)
pw2rs = get_pathways(model, pts, name2pw, root_ids)
logging.info("Performing EFMA...")
efma_dir = os.path.join(m_dir, 'efma')
create_dirs(efma_dir, rewrite)
S, efm_id2pws = analyse_model_efm(model, efma_dir, r_id2rev, tree_efm_path=treeefm_path,
max_efm_number=max_efm_number, rewrite=rewrite, pw2rs=pw2rs)
for serializer in (efm_serializer.serialize, coupled_reaction_group_serializer.serialize):
description += \
serializer(model=model, path=efma_dir, get_f_path=get_f_path, S=S, model_name=model_name)
if S.gr_id2r_id2c:
sbml = os.path.join(efma_dir, '%s.folded.xml' % safe_m_name)
create_folded_model(S, model)
libsbml.SBMLWriter().writeSBMLToFile(doc, sbml)
if not S or not S.efm_id2i:
description += describe('nothing_found.html')
model_id2sbml[safe_m_name] = sbml
model_id2S[safe_m_name] = S
model_id2efm_id2pws[safe_m_name] = efm_id2pws
model_id2cofactors[safe_m_name] = cofactors
modeld_id2m_id2chebi_id[safe_m_name] = m_id2ch_id
tab2html['Analysis of %s' % short_model_name] = description, None
cofactors = set()
m_id2ch_id = {}
if len(model_id2sbml) > 1:
mm_dir = os.path.join(res_dir, 'merged_model')
create_dirs(mm_dir)
sbml, S, model_id2id2id, common_ids, model_id2dfs, mappings = combine_models(model_id2sbml, model_id2S, mm_dir)
for model_id in model_id2sbml.keys():
efm_id2pws.update({model_id2id2id[model_id][efm_id]: pws
for (efm_id, pws) in model_id2efm_id2pws[model_id].items()
if efm_id in model_id2id2id[model_id]})
cofactors |= {model_id2id2id[model_id][m_id] for m_id in model_id2cofactors[model_id]
if m_id in model_id2id2id[model_id]}
m_id2ch_id.update({model_id2id2id[model_id][m_id]: ch_id
for (m_id, ch_id) in modeld_id2m_id2chebi_id[model_id].items()
if m_id in model_id2id2id[model_id]})
tab2html['Model comparison'] = mapping_serializer.serialize(model_id2dfs, *mappings, mm_dir, get_f_path), None
title = 'Combined model analysis'
else:
model_id, sbml = next(model_id2sbml.items())
efm_id2pws = model_id2efm_id2pws[model_id]
cofactors = model_id2cofactors[model_id]
m_id2ch_id = modeld_id2m_id2chebi_id[model_id]
S = model_id2S[model_id].get_main_S()
info, title, id2color = '', 'Model analysis', None
# Communities
logging.info("Analysing communities...")
comm_dir = os.path.join(res_dir, 'communities')
create_dirs(comm_dir, rewrite)
# id2cluster = detect_communities_by_inputs_of_type(S, 'AMINO ACID', m_id2ch_id, chebi)
id2cluster = detect_communities_by_boundary_metabolites(S, cofactors=cofactors, threshold=50)
if id2cluster:
doc = libsbml.SBMLReader().readSBML(sbml)
model = doc.getModel()
description = \
community_serializer.serialize(model, S, id2cluster, comm_dir, get_f_path, m_id2ch_id, chebi)
if len(model_id2sbml) > 1:
tab2html['Model comparison'] = tab2html['Model comparison'][0] + description, None
else:
tab2html['EFM communities'] = description, None
serialize(res_dir, tab2html, title)
<body>
<br/>
<p class="centre">We are visualizing your model now...</p>
<br/>
<img class="img-centre" src="http://mimoza.bordeaux.inria.fr/lib/modelmap/ajax-loader.gif" id="img" />
<div id="hidden" style="visibility:hidden;height:0px;">''')
sys.stdout.flush()
temp = os.dup(sys.stdout.fileno())
try:
url = '/%s/comp.html' % m_dir_id
if not os.path.exists(os.path.join('..', m_dir_id, 'comp.html')):
chebi = parse_simple(get_chebi())
reader = libsbml.SBMLReader()
input_document = reader.readSBML(groups_sbml)
input_model = input_document.getModel()
# sbml -> tulip graph
logging.info('sbml -> tlp')
graph, c_id2info, c_id2outs, chebi, ub_sps = import_sbml(
input_model, groups_sbml)
try:
n2xy = parse_layout_sbml(groups_sbml)
except LoPlError:
n2xy = None
fc, (n2lo,
def analyse_model(
sbml,
out_r_id,
out_rev,
res_dir,
in_m_id,
out_m_id,
in_r_id2rev=None,
threshold=ZERO_THRESHOLD,
do_fva=True,
do_fba=True,
do_efm=True,
max_efm_number=1000,
mask_shift=4,
get_f_path=None,
tree_efm_path=TREEEFM_PATH,
main_dir=None,
rewrite=True,
):
model_name = get_model_name(sbml)
logging.info("Analysing %s..." % model_name)
# create directories to store results
logging.info("Preparing directories...")
res_dir = os.path.join(res_dir, "".join(ch for ch in model_name.replace(" ", "_") if ch.isalnum() or "_" == ch))
create_dirs(res_dir, False)
if not get_f_path:
get_f_path = lambda f: os.path.join("..", os.path.relpath(f, res_dir))
doc = libsbml.SBMLReader().readSBML(sbml)
model = doc.getModel()
if in_r_id2rev:
constraint_exchange_reactions(model, forsed_r_id2rev=in_r_id2rev)
libsbml.SBMLWriter().writeSBMLToFile(doc, sbml)
# copy our model in the result directory
if os.path.normpath(res_dir) != os.path.normpath(os.path.dirname(sbml)):
shutil.copy(sbml, res_dir)
sbml = os.path.join(res_dir, os.path.basename(sbml))
r_id2rev = dict(in_r_id2rev)
r_id2rev[out_r_id] = out_rev
description = model_serializer.serialize(sbml, model, model_name, r_id2rev, res_dir, get_f_path)
r_id2mask, layer2mask, vis_r_ids, main_layer = defaultdict(lambda: 0), {}, set(), None
cobra_model, opt_val, objective_sense = None, None, MINIMIZE if out_rev else MAXIMIZE
if do_fva:
cur_dir = _prepare_dir(res_dir, "fva", "Performing FVA...")
cobra_model = create_cobra_model_from_sbml_file(sbml) if not cobra_model else cobra_model
r_id2bounds, opt_val = analyse_by_fva(
cobra_model=cobra_model, bm_r_id=out_r_id, objective_sense=objective_sense, threshold=threshold
)
if opt_val:
mask_shift = update_vis_layers(
(r_id for (r_id, (l, u)) in r_id2bounds.items() if l * u > 0),
"FVA essential",
r_id2mask,
layer2mask,
mask_shift,
vis_r_ids,
)
main_layer = "FVA essential"
fva_sbml = os.path.join(cur_dir, "Model_FVA.xml")
sbml = create_fva_model(sbml, r_id2bounds, fva_sbml)
description += fva_serializer.serialize(
cobra_model, opt_val, r_id2bounds, objective_sense, out_r_id, cur_dir, get_f_path, sbml
)
if do_fba:
cur_dir = _prepare_dir(res_dir, "fba", "Performing FBA...")
cobra_model = create_cobra_model_from_sbml_file(sbml) if not cobra_model else cobra_model
r_id2val, opt_val = analyse_by_fba(
cobra_model, bm_r_id=out_r_id, objective_sense=objective_sense, threshold=threshold
)
if opt_val:
mask_shift = update_vis_layers(r_id2val.keys(), "FBA", r_id2mask, layer2mask, mask_shift, vis_r_ids)
main_layer = "FBA"
description += fba_serializer.serialize(
cobra_model, opt_val, r_id2val, objective_sense, out_r_id, cur_dir, get_f_path
)
S = None
if do_efm:
cur_dir = _prepare_dir(res_dir, "efma", "Performing EFMA...", rewrite=rewrite)
doc = libsbml.SBMLReader().readSBML(sbml)
model = doc.getModel()
name2pw = get_name2pw()
pts = parse_simple(get_pts())
root_ids = {t.get_id() for t in pts.get_roots()}
pw2rs = get_pathways(model, pts, name2pw, root_ids)
S, efm_id2pws = analyse_model_efm(
model,
cur_dir,
r_id2rev,
tree_efm_path=tree_efm_path,
max_efm_number=max_efm_number,
rewrite=rewrite,
pw2rs=pw2rs,
)
for serializer in (efm_serializer.serialize, coupled_reaction_group_serializer.serialize):
description += serializer(
model=model,
path=cur_dir,
get_f_path=get_f_path,
in_m_id=in_m_id,
out_m_id=out_m_id,
out_r_id=out_r_id,
S=S,
model_name=model_name,
main_dir=main_dir,
)
if S.gr_id2r_id2c:
clique_merged_sbml = os.path.join(cur_dir, "Model_folded.xml")
r_id2new_r_id = create_folded_model(S, model)
libsbml.SBMLWriter().writeSBMLToFile(doc, clique_merged_sbml)
sbml = clique_merged_sbml
vis_r_ids |= {cl_id for (r_id, cl_id) in r_id2new_r_id.items() if r_id in vis_r_ids}
for r_id, new_r_id in r_id2new_r_id.items():
if r_id in r_id2mask:
r_id2mask[new_r_id] |= r_id2mask[r_id]
if not opt_val and (not S or not S.efm_id2i):
description += describe("nothing_found.html")
return model_name, S, sbml, vis_r_ids, description, mask_shift, r_id2mask, layer2mask, main_layer
<body>
<br/>
<p class="centre">We are visualizing your model now...</p>
<br/>
<img class="img-centre" src="http://mimoza.bordeaux.inria.fr/lib/modelmap/ajax-loader.gif" id="img" />
<div id="hidden" style="visibility:hidden;height:0px;">''')
sys.stdout.flush()
temp = os.dup(sys.stdout.fileno())
try:
url = '/%s/comp.html' % m_dir_id
if not os.path.exists(os.path.join('..', m_dir_id, 'comp.html')):
chebi = parse_simple(get_chebi())
reader = libsbml.SBMLReader()
input_document = reader.readSBML(groups_sbml)
input_model = input_document.getModel()
# sbml -> tulip graph
logging.info('sbml -> tlp')
graph, c_id2info, c_id2outs, chebi, ub_sps = import_sbml(input_model, groups_sbml)
try:
n2xy = parse_layout_sbml(groups_sbml)
except LoPlError:
n2xy = None
fc, (n2lo, e2lo), hidden_c_ids, c_id_hidden_ubs = graph2geojson(c_id2info, c_id2outs, graph, n2xy, onto=chebi)
c_id2out_c_id = {}
__author__ = 'anna'
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(description="Generalizes an SBML model.")
parser.add_argument('--model', required=True, type=str,
help="input model in SBML format")
parser.add_argument('--output_model', default=None, type=str,
help="path to the output generalized model in SBML format")
parser.add_argument('--groups_model', default=None, type=str,
help="path to the output model in SBML format with groups extension to encode similar elements")
parser.add_argument('--verbose', action="store_true", help="print logging information")
parser.add_argument('--log', default=None, help="a log file")
params = parser.parse_args()
prefix = os.path.splitext(params.model)[0]
if not params.output_model:
params.output_model = "%s_generalized.xml" % prefix
if not params.groups_model:
params.groups_model = "%s_with_groups.xml" % prefix
if params.verbose:
logging.basicConfig(level=logging.INFO)
logging.info("parsing ChEBI...")
ontology = parse_simple(get_chebi())
r_id2clu, s_id2clu, _, _ = generalize_model(params.model, ontology, params.groups_model, params.output_model,
ub_chebi_ids={'chebi:ch'})
def process_sbml(sbml,
verbose,
ub_ch_ids=None,
web_page_prefix=None,
generalize=True,
log_file=None,
id2mask=None,
layer2mask=DEFAULT_LAYER2MASK,
tab2html=None,
title=None,
h1=None,
id2color=None,
tabs={ABOUT_TAB, DOWNLOAD_TAB},
info='',
invisible_layers=None,
sbgn=True,
cytoscape=True):
"""
Generalizes and visualizes a given SBML model.
:param sbml: a path to the input SBML file
:param verbose: if logging information should be printed
:param ub_ch_ids: optional, ChEBI ids to be considered as ubiquitous. If left None, will be calculated automatically.
:param web_page_prefix: optional, how this model's webpage will be identified.
If left None an identifier will be generated based on the SBML file's md5.
:param generalize: optional, whether the generalization should be performed. The default is True
:param log_file: optional, a file where the logging information should be redirected
(only needed if verbose is set to True)
:param id2mask: optional,
:param layer2mask: optional, a dict storing the correspondence between a layer name and an its id mask
:param tab2html: optional,
:param title: optional, the title for the web page
:param h1: optional, the main header of the web page
:param id2color: optional,
:param tabs: optional, a set of names of tabs that should be shown
:param info: optional, additional information to be displayed in the bottom of the web page
:param invisible_layers: optional, the layers of the visualized metabolic map that should be hidden
:return: void
"""
# Read the SBML
reader = libsbml.SBMLReader()
doc = reader.readSBML(sbml)
model = doc.getModel()
if not model:
raise Exception(
"The model should be in SBML format, check your file %s" % sbml)
model_id = model.getId()
if not model_id:
sbml_name = os.path.splitext(os.path.basename(sbml))[0]
model.setId(sbml_name)
model_id = sbml_name
# Prepare the output directories
web_page_prefix = web_page_prefix if web_page_prefix else check_md5(sbml)
sbml_dir = dirname(abspath(sbml))
directory = os.path.join(sbml_dir, web_page_prefix)
if not os.path.exists(directory):
os.makedirs(directory)
lib_path = os.path.join(directory, 'lib')
if not os.path.exists(lib_path):
copytree(get_lib(), lib_path)
# Prepare the logger
if verbose:
logging.captureWarnings(True)
logging.basicConfig(level=logging.INFO,
format='%(asctime)s: %(message)s',
datefmt="%Y-%m-%d %H:%M:%S",
filename=log_file)
# Generalize the model if needed
groups_sbml = os.path.join(directory, '%s_with_groups.xml' % model_id)
gen_sbml = os.path.join(directory, '%s_generalized.xml' % model_id)
if check_for_groups(sbml, SBO_CHEMICAL_MACROMOLECULE,
GROUP_TYPE_UBIQUITOUS):
if sbml != groups_sbml:
if not libsbml.SBMLWriter().writeSBMLToFile(doc, groups_sbml):
raise Exception("Could not write your model to %s" %
groups_sbml)
else:
chebi = parse_simple(get_chebi())
if generalize:
logging.info('Generalizing the model...')
generalize_model(sbml,
chebi,
groups_sbml,
gen_sbml,
ub_chebi_ids=ub_ch_ids)
else:
gen_sbml = None
logging.info('Ubiquitizing the model...')
ubiquitize_model(sbml, chebi, groups_sbml, ub_chebi_ids=ub_ch_ids)
# Visualize the model
reader = libsbml.SBMLReader()
input_document = reader.readSBML(groups_sbml)
input_model = input_document.getModel()
root, c_id2info, c_id2outs, chebi, ub_sps = import_sbml(
input_model, groups_sbml)
c_id2out_c_id = {}
for c_id, c_info in c_id2info.items():
_, _, (_, out_c_id) = c_info
if out_c_id:
c_id2out_c_id[c_id] = out_c_id
try:
n2xy = parse_layout_sbml(sbml)
if n2xy:
logging.info('Found layout in the model...')
r_size = next((n2xy[r.getId()][1][0]
for r in input_model.getListOfReactions()
if r.getId() in n2xy), None)
if r_size:
scale_factor = REACTION_SIZE / r_size
if scale_factor != 1:
keys = n2xy.keys()
for n_id in keys:
value = n2xy[n_id]
if isinstance(value, dict):
value = {
r_id:
(scale(xy,
scale_factor), scale(wh, scale_factor))
for (r_id, (xy, wh)) in value.items()
}
else:
xy, wh = value
value = scale(xy, scale_factor), scale(
wh, scale_factor)
n2xy[n_id] = value
except LoPlError:
n2xy = None
fc, (n2lo, e2lo), hidden_c_ids, c_id_hidden_ubs = \
graph2geojson(c_id2info, c_id2outs, root, n2xy, id2mask=id2mask, onto=chebi,
colorer=color if not id2color else lambda graph: color_by_id(graph, id2color))
if n2lo:
groups_document = reader.readSBML(groups_sbml)
groups_model = groups_document.getModel()
if gen_sbml:
gen_document = reader.readSBML(gen_sbml)
gen_model = gen_document.getModel()
else:
gen_model = False
save_as_layout_sbml(groups_model, gen_model, groups_sbml, gen_sbml,
n2lo, ub_sps)
if sbgn:
groups_sbgn = os.path.join(directory, '%s.sbgn' % model_id)
gen_sbgn = os.path.join(directory,
'%s_generalized.sbgn' % model_id)
try:
save_as_sbgn(n2lo, e2lo, groups_model, groups_sbgn)
logging.info(' exported as SBGN %s' % groups_sbgn)
except Exception as e:
logging.error("Didn't manage to save to SBGN: %s" % e)
if gen_model:
try:
save_as_sbgn(n2lo, e2lo, gen_model, gen_sbgn)
logging.info(' exported as SBGN %s' % groups_sbgn)
except Exception as e:
logging.error("Didn't manage to save to SBGN: %s" % e)
if cytoscape:
out_json = os.path.join(directory, '%s.cyjs' % model_id)
save_as_cytoscape_json(n2lo, model, out_json, ub_sps)
logging.info(' exported as Cytoscape json %s' % out_json)
if gen_model:
out_json = os.path.join(directory,
'%s_generalized.cyjs' % model_id)
save_as_cytoscape_json(n2lo, gen_model, out_json, ub_sps)
# Serialize the result
serialize(directory=directory,
m_dir_id=web_page_prefix,
input_model=input_model,
c_id2level2features=fc,
c_id2out_c_id=c_id2out_c_id,
hidden_c_ids=hidden_c_ids,
c_id_hidden_ubs=c_id_hidden_ubs,
tabs=tabs,
groups_sbml=groups_sbml,
layer2mask=layer2mask,
tab2html=tab2html,
title=title,
h1=h1,
invisible_layers=invisible_layers)
if not params.chebi:
params.chebi = get_chebi()
prefix = os.path.splitext(params.model)[0]
if not params.merged_model:
params.merged_model = "%s.xml" % prefix
if not params.output_model:
params.output_model = "%s_generalized.xml" % prefix
if not params.groups_model:
params.groups_model = "%s_with_groups.xml" % prefix
if params.verbose:
logging.basicConfig(level=logging.INFO)
logging.info("parsing ChEBI...")
ontology = parse_simple(params.chebi)
if os.path.isdir(params.model):
in_sbml_list = ['%s/%s' % (params.model, f) for f in glob.glob(os.path.join(params.model, '*'))
if os.path.splitext(f)[1] in [".xml", ".sbml"]]
for sbml in in_sbml_list:
doc = libsbml.SBMLReader().readSBML(sbml)
model = doc.getModel()
print(sbml, model.getNumSpecies(), model.getNumReactions())
merge_models(in_sbml_list, params.merged_model)
sbml = params.merged_model
else:
sbml = params.model
r_id2clu, s_id2clu, _, _ = generalize_model(sbml, ontology, params.groups_model, params.output_model,
ub_chebi_ids={'chebi:ch'})
if os.path.isdir(params.model):
serialize_generalization(r_id2clu, s_id2clu, params.groups_model, ontology,
