def assemble_pysb(self, mode='local', bucket=EMMAA_BUCKET_NAME):
"""Assemble the model into PySB and return the assembled model."""
if not self.assembled_stmts:
self.run_assembly()
pa = PysbAssembler()
pa.add_statements(self.assembled_stmts)
pysb_model = pa.make_model()
if mode == 's3':
for exp_f in self.export_formats:
if exp_f not in {
'sbml', 'kappa', 'kappa_im', 'kappa_cm', 'bngl',
'sbgn', 'pysb_flat', 'gromet'
}:
continue
elif exp_f == 'gromet':
# Export gromet here if there's no separate "dynamic" pysb
if 'dynamic' not in self.assembly_config:
fname = f'gromet_{self.date_str}.json'
pysb_to_gromet(pysb_model, self.name,
self.assembled_stmts, fname)
else:
fname = f'{exp_f}_{self.date_str}.{exp_f}'
pa.export_model(exp_f, fname)
logger.info(f'Uploading {fname}')
client = get_s3_client(unsigned=False)
client.upload_file(fname, bucket,
f'exports/{self.name}/{fname}')
return pysb_model
def post(self):
"""Assemble INDRA Statements and return PySB model string.
Parameters
----------
statements : list[indra.statements.Statement.to_json()]
A list of INDRA Statements to assemble.
export_format : str
The format to export into, for instance "kappa", "bngl",
"sbml", "matlab", "mathematica", "potterswheel". See
http://pysb.readthedocs.io/en/latest/modules/export/index.html
for a list of supported formats. In addition to the formats
supported by PySB itself, this method also provides "sbgn"
output.
Returns
-------
image or model
Assembled exported model. If export_format is kappa_im or kappa_cm,
image is returned. Otherwise model string is returned.
"""
args = request.json
stmts_json = args.get('statements')
export_format = args.get('export_format')
stmts = stmts_from_json(stmts_json)
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model()
try:
for m in pa.model.monomers:
pysb_assembler.set_extended_initial_condition(pa.model, m, 0)
except Exception as e:
logger.exception(e)
if not export_format:
model_str = pa.print_model()
elif export_format in ('kappa_im', 'kappa_cm'):
fname = 'model_%s.png' % export_format
root = os.path.dirname(os.path.abspath(fname))
graph = pa.export_model(format=export_format, file_name=fname)
with open(fname, 'rb') as fh:
data = 'data:image/png;base64,%s' % \
base64.b64encode(fh.read()).decode()
return {'image': data}
else:
try:
model_str = pa.export_model(format=export_format)
except Exception as e:
logger.exception(e)
model_str = ''
res = {'model': model_str}
return res
def test_nl_modeling():
# 1 code chunk
from indra.sources import trips
model_text = 'MAP2K1 phosphorylates MAPK1 and DUSP6 dephosphorylates MAPK1.'
tp = trips.process_text(model_text)
# 2nd code chunk
for st in tp.statements:
assert st.evidence[0].text # Replaces a print statement in the doc
# 3rd code chunk
from indra.assemblers.pysb import PysbAssembler
pa = PysbAssembler()
pa.add_statements(tp.statements)
pa.make_model(policies='two_step')
# 4th code chunk
for monomer in pa.model.monomers:
assert monomer # This replaces a print statements in the doc
# 5th code chunk
for rule in pa.model.rules:
assert rule # This replaces a print statements in the doc
# 6th code chunk
for parameter in pa.model.parameters:
assert parameter # This replaces a print statements in the doc
# 7th code chunk
for annotation in pa.model.annotations:
assert annotation # This replaces a print statements in the doc
# 8th code chunk (this code is currently in a commented out section)
pa.set_context('A375_SKIN')
for monomer_pattern, parameter in pa.model.initial_conditions:
assert monomer_pattern
assert parameter.value
# 9th code chunk
_ = pa.export_model('sbml')
assert _
_ = pa.export_model('bngl')
assert _
def test_eidos_to_pysb():
stmts = __get_stmts_from_remote_jsonld()
pa = PysbAssembler()
# Make sure these don't error
pa.add_statements(stmts)
pa.make_model()
for fmt in ['kappa', 'sbml', 'sbgn']:
exp_str = pa.export_model(fmt)
assert exp_str, "Got no exported model from eidos->psyb to %s." % fmt
return
def make_sbgn(pysb_model, model_id):
pa = PysbAssembler()
pa.model = pysb_model
for m in pysb_model.monomers:
pysb_assembler.set_extended_initial_condition(pysb_model, m, 0)
try:
sbgn_str = pa.export_model('sbgn')
except BngInterfaceError:
logger.error('Reaction network could not be generated for SBGN.')
return None
return sbgn_str
def make_sbgn(pysb_model, model_id):
pa = PysbAssembler()
pa.model = pysb_model
for m in pysb_model.monomers:
pysb_assembler.set_extended_initial_condition(pysb_model, m, 0)
try:
sbgn_str = pa.export_model('sbgn')
except BngInterfaceError:
logger.error('Reaction network could not be generated for SBGN.')
return None
return sbgn_str
def test_getting_started7_8():
# Chunk 7
stmts = gn_stmts # Added only in this test, not in docs
from indra.assemblers.pysb import PysbAssembler
pa = PysbAssembler()
pa.add_statements(stmts)
model = pa.make_model()
assert model
# Chunk 8
sbml_model = pa.export_model('sbml')
assert sbml_model
def test_eidos_to_pysb():
stmts = __get_stmts_from_remote_jsonld()
pa = PysbAssembler()
# Make sure these don't error
pa.add_statements(stmts)
model = pa.make_model()
assert model.rules, model.rules
for fmt in ['kappa', 'sbml', 'sbgn']:
exp_str = pa.export_model(fmt)
assert exp_str, "Got no exported model from eidos->psyb to %s." % fmt
return
def assemble_pysb():
"""Assemble INDRA Statements and return PySB model string."""
if request.method == 'OPTIONS':
return {}
response = request.body.read().decode('utf-8')
body = json.loads(response)
stmts_json = body.get('statements')
export_format = body.get('export_format')
stmts = stmts_from_json(stmts_json)
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model()
try:
for m in pa.model.monomers:
pysb_assembler.set_extended_initial_condition(pa.model, m, 0)
except Exception as e:
logger.exception(e)
if not export_format:
model_str = pa.print_model()
elif export_format in ('kappa_im', 'kappa_cm'):
fname = 'model_%s.png' % export_format
root = os.path.dirname(os.path.abspath(fname))
graph = pa.export_model(format=export_format, file_name=fname)
with open(fname, 'rb') as fh:
data = 'data:image/png;base64,%s' % \
base64.b64encode(fh.read()).decode()
return {'image': data}
else:
try:
model_str = pa.export_model(format=export_format)
except Exception as e:
logger.exception(e)
model_str = ''
res = {'model': model_str}
return res
def assemble_pysb():
"""Assemble INDRA Statements and return PySB model string."""
if request.method == 'OPTIONS':
return {}
response = request.body.read().decode('utf-8')
body = json.loads(response)
stmts_json = body.get('statements')
export_format = body.get('export_format')
stmts = stmts_from_json(stmts_json)
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model()
try:
for m in pa.model.monomers:
pysb_assembler.set_extended_initial_condition(pa.model, m, 0)
except Exception as e:
logger.exception(e)
if not export_format:
model_str = pa.print_model()
elif export_format in ('kappa_im', 'kappa_cm'):
fname = 'model_%s.png' % export_format
root = os.path.dirname(os.path.abspath(fname))
graph = pa.export_model(format=export_format, file_name=fname)
with open(fname, 'rb') as fh:
data = 'data:image/png;base64,%s' % \
base64.b64encode(fh.read()).decode()
return {'image': data}
else:
try:
model_str = pa.export_model(format=export_format)
except Exception as e:
logger.exception(e)
model_str = ''
res = {'model': model_str}
return res
def assemble_pysb():
"""Assemble INDRA Statements and return PySB model string."""
if request.method == 'OPTIONS':
return {}
response = request.body.read().decode('utf-8')
body = json.loads(response)
stmts_json = body.get('statements')
export_format = body.get('export_format')
stmts = stmts_from_json(stmts_json)
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model()
if not export_format:
model_str = pa.print_model()
else:
try:
model_str = pa.export_model(format=export_format)
except Exception as e:
logger.exception(e)
model_str = ''
res = {'model': model_str}
return res
def make_contact_map(pysb_model):
"""Return a Kappa contact map."""
pa = PysbAssembler()
pa.model = pysb_model
cm = pa.export_model('kappa_cm')
return cm
def make_influence_map(pysb_model):
"""Return a Kappa influence map."""
pa = PysbAssembler()
pa.model = pysb_model
im = pa.export_model('kappa_im')
return im
