def get_subnetwork(statements, nodes):
"""Return a PySB model based on a subset of given INDRA Statements.
Statements are first filtered for nodes in the given list and other nodes
are optionally added based on relevance in a given network. The filtered
statements are then assembled into an executable model using INDRA's
PySB Assembler.
Parameters
----------
statements : list[indra.statements.Statement]
A list of INDRA Statements to extract a subnetwork from.
nodes : list[str]
The names of the nodes to extract the subnetwork for.
Returns
-------
model : pysb.Model
A PySB model object assembled using INDRA's PySB Assembler from
the INDRA Statements corresponding to the subnetwork.
"""
filtered_statements = _filter_statements(statements, nodes)
pa = PysbAssembler()
pa.add_statements(filtered_statements)
model = pa.make_model()
return model
def assemble_pysb(self):
"""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()
return pysb_model
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 processText(Text):
pa = PysbAssembler()
# Process a natural language description of a mechanism
trips_processor = trips.process_text(Text)
# Collect extracted mechanisms in PysbAssembler
pa.add_statements(trips_processor.statements)
# Assemble the model
model = pa.make_model(policies='two_step')
return model
def test_grounded_active_pattern():
a = Agent('A', db_refs={'HGNC': '1234'})
b = Agent('B', db_refs={'HGNC': '5678'})
b_phos = Agent('B', mods=[ModCondition('phosphorylation', 'S', '100')],
db_refs={'HGNC': '5678'})
b_act = Agent('B', activity=ActivityCondition('activity', True),
db_refs={'HGNC': '5678'})
st1 = Phosphorylation(a, b, 'S', '100')
st2 = ActiveForm(b_phos, 'activity', True)
pysba = PysbAssembler([st1, st2])
model = pysba.make_model(policies='one_step')
mps = list(pa.grounded_monomer_patterns(model, b_act))
def test_readme_using_indra1():
from indra.sources import trips
from indra.assemblers.pysb import PysbAssembler
pa = PysbAssembler()
# Process a natural language description of a mechanism
trips_processor = trips.process_text(
'MEK2 phosphorylates ERK1 at Thr-202 and Tyr-204')
# Collect extracted mechanisms in PysbAssembler
pa.add_statements(trips_processor.statements)
# Assemble the model
model = pa.make_model(policies='two_step')
assert model
def test_grounded_active_pattern():
a = Agent('A', db_refs={'HGNC': '1234'})
b = Agent('B', db_refs={'HGNC': '5678'})
b_phos = Agent('B', mods=[ModCondition('phosphorylation', 'S', '100')],
db_refs={'HGNC': '5678'})
b_act = Agent('B', activity=ActivityCondition('activity', True),
db_refs={'HGNC': '5678'})
st1 = Phosphorylation(a, b, 'S', '100')
st2 = ActiveForm(b_phos, 'activity', True)
pysba = PysbAssembler([st1, st2])
model = pysba.make_model(policies='one_step')
mps = list(pa.grounded_monomer_patterns(model, b_act))
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 test_missing_catalytic_default_site():
c8 = Agent('CASP8', activity=ActivityCondition('catalytic', True))
c3 = Agent('CASP3')
stmt = Activation(c8, c3, 'catalytic')
# Interactions only
pa = PysbAssembler([stmt])
model = pa.make_model(policies='interactions_only')
# One step
pa = PysbAssembler([stmt])
model = pa.make_model(policies='one_step')
# Two step
pa = PysbAssembler([stmt])
model = pa.make_model(policies='two_step')
def test_missing_transcription_default_site():
p53 = Agent('TP53', activity=ActivityCondition('transcription', True))
bax = Agent('BAX')
stmt = Activation(p53, bax)
# Interactions only
pa = PysbAssembler([stmt])
model = pa.make_model(policies='interactions_only')
# One step
pa = PysbAssembler([stmt])
model = pa.make_model(policies='one_step')
# Two step
pa = PysbAssembler([stmt])
model = pa.make_model(policies='two_step')
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_convert_subj():
stmt = Conversion(Agent('PIK3CA'), [Agent('PIP2')], [Agent('PIP3')])
pa = PysbAssembler([stmt])
pa.make_model()
assert len(pa.model.parameters) == 4
assert len(pa.model.rules) == 1
assert len(pa.model.monomers) == 3
def test_check_model():
explain = Activation(raf, erk)
mek_active = Agent('MEK', db_refs={'FPLX': 'MEK'},
activity=ActivityCondition('activity', True))
model_stmts = [Activation(raf, mek), Activation(mek_active, erk)]
# Build the pysb model
pa = PysbAssembler()
pa.add_statements(model_stmts)
pa.make_model(policies='one_step')
md = ModelDiagnoser(model_stmts, pa.model, explain)
result = md.check_explanation()
assert result['has_explanation'] is True
path = result['explanation_path']
assert len(path) == 2
assert path[0] == model_stmts[0]
assert path[1] == model_stmts[1]
def assemble_dynamic_pysb(self, **kwargs):
"""Assemble a version of a PySB model for dynamic simulation."""
# First need to run regular assembly
if not self.assembled_stmts:
self.run_assembly()
if 'dynamic' in self.assembly_config:
logger.info('Assembling dynamic PySB model')
ap = AssemblyPipeline(self.assembly_config['dynamic'])
# Not overwrite assembled stmts
stmts = deepcopy(self.assembled_stmts)
new_stmts = ap.run(stmts)
pa = PysbAssembler()
pa.add_statements(new_stmts)
pysb_model = pa.make_model()
return pysb_model
logger.info('Did not find dynamic assembly steps')
def test_pysb_assembler_autophos1():
enz = Agent('MEK1')
stmt = Autophosphorylation(enz, 'serine', '222')
pa = PysbAssembler([stmt])
model = pa.make_model()
assert len(model.rules) == 1
assert len(model.monomers) == 1
def test_policy_object():
stmt = Phosphorylation(Agent('a'), Agent('b'))
pa = PysbAssembler([stmt])
pol = Policy('two_step')
model = pa.make_model(policies={stmt.uuid: pol})
assert len(model.rules) == 3
assert str(pol) == 'Policy(two_step)'
def test_kappa_cm_export():
stmts = [Complex([Agent('a'), Agent('b')])]
pa = PysbAssembler(stmts)
pa.make_model()
graph = pa.export_model('kappa_cm', '/dev/null')
assert len(graph.nodes()) == 2
assert len(graph.edges()) == 1
def test_pysb_assembler_actsub():
stmt = ActiveForm(Agent('BRAF', mutations=[MutCondition('600', 'V', 'E')]),
'activity', True)
pa = PysbAssembler([stmt])
model = pa.make_model(policies='two_step')
assert len(model.rules) == 0
assert len(model.monomers) == 1
def remove_kappa_dead_rules(stmts, model, dead_rules):
# FIXME: we should probably check that a statement we remove has all its
# generated rules recognized as dead. If it has at least one live rule
# coming from it, we shouldn't remove it. But the dead rules should still
# be removed somehow from the final model.
dead_uuids = set()
for rule in dead_rules:
for ann in model.annotations:
if ann.subject == rule and ann.predicate == 'from_indra_statement':
dead_uuids.add(ann.object)
all_uuids = {stmt.uuid for stmt in stmts}
live_uuids = all_uuids - dead_uuids
stmts = ac.filter_uuid_list(stmts, live_uuids)
pa = PysbAssembler()
pa.add_statements(stmts)
model = pa.make_model()
return stmts, model
def test_pysb_assembler_gef1():
gef = Agent('SOS1')
ras = Agent('HRAS')
stmt = Gef(gef, ras)
pa = PysbAssembler([stmt])
model = pa.make_model()
assert len(model.rules) == 1
assert len(model.monomers) == 2
def test_activity_activity3():
subj = Agent('Vemurafenib')
obj = Agent('BRAF')
stmt = Inhibition(subj, obj)
pa = PysbAssembler([stmt])
model = pa.make_model(policies='one_step')
assert len(model.rules) == 1
assert len(model.monomers) == 2
def test_agent_loc():
st = Phosphorylation(Agent('BRAF', location='cytoplasm'), Agent('MEK'))
pa = PysbAssembler([st])
pa.make_model()
assert len(pa.model.rules) == 1
r = pa.model.rules[0]
braf = r.reactant_pattern.complex_patterns[0].monomer_patterns[0]
assert braf.site_conditions == {'loc': 'cytoplasm'}
def test_annotation_regamount():
st1 = IncreaseAmount(Agent('BRAF', db_refs={'UP': 'P15056'}),
Agent('MAP2K2', db_refs={'HGNC': '6842'}))
st2 = DecreaseAmount(Agent('BRAF', db_refs={'UP': 'P15056'}),
Agent('MAP2K2', db_refs={'HGNC': '6842'}))
pa = PysbAssembler([st1, st2])
pa.make_model()
assert len(pa.model.annotations) == 8
def test_pysb_assembler_dephos_twostep1():
phos = Agent('PP2A')
sub = Agent('MEK1')
stmt = Dephosphorylation(phos, sub, 'serine', '222')
pa = PysbAssembler([stmt])
model = pa.make_model(policies='two_step')
assert len(model.rules) == 3
assert len(model.monomers) == 2
def test_pysb_assembler_complex_twostep():
member1 = Agent('BRAF')
member2 = Agent('MEK1')
stmt = Complex([member1, member2])
pa = PysbAssembler([stmt])
model = pa.make_model(policies='two_step')
assert len(model.rules) == 2
assert len(model.monomers) == 2
def test_activity_activity2():
subj = Agent('KRAS')
obj = Agent('BRAF')
stmt = Activation(subj, obj)
pa = PysbAssembler([stmt])
model = pa.make_model(policies='one_step')
assert len(model.rules) == 1
assert len(model.monomers) == 2
def test_pysb_assembler_gap1():
gap = Agent('NF1')
ras = Agent('HRAS')
stmt = Gap(gap, ras)
pa = PysbAssembler([stmt])
model = pa.make_model()
assert len(model.rules) == 1
assert len(model.monomers) == 2
def test_pysb_assembler_phos_twostep_local():
enz = Agent('BRAF')
sub = Agent('MEK1')
stmt = Phosphorylation(enz, sub, 'serine', '222')
pa = PysbAssembler([stmt])
model = pa.make_model(policies='two_step')
assert len(model.rules) == 3
assert len(model.monomers) == 2
def test_non_python_name_phos():
st = Phosphorylation(Agent('14-3-3'), Agent('BRAF kinase'))
pa = PysbAssembler([st])
pa.make_model()
names = [m.name for m in pa.model.monomers]
assert 'BRAF_kinase' in names
assert 'p14_3_3' in names
bng.generate_equations(pa.model)
def test_pysb_assembler_transphos1():
egfr = Agent('EGFR')
enz = Agent('EGFR', bound_conditions=[BoundCondition(egfr, True)])
stmt = Transphosphorylation(enz, 'tyrosine')
pa = PysbAssembler([stmt])
model = pa.make_model()
assert len(model.rules) == 1
assert len(model.monomers) == 1
def test_pysb_assembler_autophos2():
raf1 = Agent('RAF1')
enz = Agent('MEK1', bound_conditions=[BoundCondition(raf1, True)])
stmt = Autophosphorylation(enz, 'serine', '222')
pa = PysbAssembler([stmt])
model = pa.make_model()
assert len(model.rules) == 1
assert len(model.monomers) == 2
def test_pysb_assembler_dephos_noenz():
enz = None
sub = Agent('MEK1')
stmt = Phosphorylation(enz, sub, 'serine', '222')
pa = PysbAssembler([stmt])
model = pa.make_model()
assert len(model.rules) == 0
assert len(model.monomers) == 0
def assemble_model(stmts):
pa = PysbAssembler()
pa.add_statements(stmts)
model = pa.make_model(policies='one_step')
pa.add_default_initial_conditions(100.0)
try:
targeted_agents = get_targeted_agents(stmts)
no_upstream_active_agents = get_no_upstream_active_agents(stmts)
except:
targeted_agents = []
no_upstream_active_agents = []
try:
chemical_agents = get_chemical_agents(stmts)
except:
chemical_agents = []
for m in model.monomers:
try:
if m.name in targeted_agents or m.name in no_upstream_active_agents:
pysb_assembler.set_base_initial_condition(model,
model.monomers[m.name], 50.0)
pysb_assembler.set_extended_initial_condition(model, m, 50.0)
elif m.name in chemical_agents:
pysb_assembler.set_base_initial_condition(model,
model.monomers[m.name], 10000.0)
else:
pysb_assembler.set_extended_initial_condition(model, m, 0)
except:
pysb_assembler.set_extended_initial_condition(model, m, 0)
# Tweak parameters
for param in model.parameters:
if 'kf' in param.name and 'bind' in param.name:
param.value = param.value * 100
return model
def test_propose_statement():
jun = Agent('JUN', db_refs={'HGNC':'6204', 'UP': 'P05412'})
explain = Activation(raf, jun)
erk_active = Agent('ERK', db_refs={'FPLX': 'ERK'},
activity=ActivityCondition('activity', True))
# Leave out MEK activates ERK
model_stmts = [Activation(raf, mek), Activation(erk_active, jun)]
# Build the pysb model
pa = PysbAssembler()
pa.add_statements(model_stmts)
pa.make_model(policies='one_step')
md = ModelDiagnoser(model_stmts, pa.model, explain)
result = md.check_explanation()
assert result['has_explanation'] is False
assert result.get('explanation_path') is None
inf_prop = result.get('connect_rules')
assert inf_prop == ('RAF_activates_MEK_activity',
'ERK_act_activates_JUN_activity'), inf_prop
stmt_prop = result.get('connect_stmts')
assert stmt_prop == (model_stmts[0], model_stmts[1])
stmt_suggestions = md.suggest_statements(*stmt_prop)
def assemble_model(stmts):
pa = PysbAssembler()
pa.add_statements(stmts)
model = pa.make_model(policies='one_step')
pa.add_default_initial_conditions(100.0)
try:
targeted_agents = get_targeted_agents(stmts)
no_upstream_active_agents = get_no_upstream_active_agents(stmts)
except:
targeted_agents = []
no_upstream_active_agents = []
try:
chemical_agents = get_chemical_agents(stmts)
except:
chemical_agents = []
for m in model.monomers:
try:
if m.name in targeted_agents or m.name in no_upstream_active_agents:
pysb_assembler.set_base_initial_condition(model,
model.monomers[m.name], 50.0)
pysb_assembler.set_extended_initial_condition(model, m, 50.0)
elif m.name in chemical_agents:
pysb_assembler.set_base_initial_condition(model,
model.monomers[m.name], 10000.0)
else:
pysb_assembler.set_extended_initial_condition(model, m, 0)
except:
pysb_assembler.set_extended_initial_condition(model, m, 0)
# Tweak parameters
for param in model.parameters:
if 'kf' in param.name and 'bind' in param.name:
param.value = param.value * 100
return model
def get_subnetwork(statements, nodes, relevance_network=None,
relevance_node_lim=10):
"""Return a PySB model based on a subset of given INDRA Statements.
Statements are first filtered for nodes in the given list and other nodes
are optionally added based on relevance in a given network. The filtered
statements are then assembled into an executable model using INDRA's
PySB Assembler.
Parameters
----------
statements : list[indra.statements.Statement]
A list of INDRA Statements to extract a subnetwork from.
nodes : list[str]
The names of the nodes to extract the subnetwork for.
relevance_network : Optional[str]
The UUID of the NDEx network in which nodes relevant to the given
nodes are found.
relevance_node_lim : Optional[int]
The maximal number of additional nodes to add to the subnetwork
based on relevance.
Returns
-------
model : pysb.Model
A PySB model object assembled using INDRA's PySB Assembler from
the INDRA Statements corresponding to the subnetwork.
"""
if relevance_network is not None:
relevant_nodes = _find_relevant_nodes(nodes, relevance_network,
relevance_node_lim)
all_nodes = nodes + relevant_nodes
else:
all_nodes = nodes
filtered_statements = _filter_statements(statements, all_nodes)
pa = PysbAssembler()
pa.add_statements(filtered_statements)
model = pa.make_model()
return model
def assemble_model(model_name, statements):
# Pysb assembly
pa = PysbAssembler()
pa.add_statements(statements)
ts = time.time()
model = pa.make_model()
te = time.time()
print('Assembly took %.2fs' % (te-ts))
model.name = model_name
add_observable(model)
set_parameters(model)
# Save and return model
pa.model = model
pa.save_model('%s.py' % model_name)
return model
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 replace_agent(self, agent_name, agent_replacement_names, model_id):
"""Replace an agent in a model with other agents.
This is used, for instance, to expand a protein family to
multiple specific proteins.
"""
for stmt in self.statements[model_id-1]:
agent_key = [i for i, m in enumerate(stmt.agent_list())
if m is not None and m.name == agent_name]
if agent_key:
self.statements[model_id-1].remove(stmt)
for p in agent_replacement_names:
s = copy.deepcopy(stmt)
if isinstance(stmt, Complex):
s.members[agent_key[0]].name = p
else:
s.__dict__[agent_key[0]].name = p
self.extend_statements([s], model_id)
pa = PysbAssembler()
pa.add_statements(self.statements[model_id-1])
model = pa.make_model()
pa.add_default_initial_conditions(self.default_initial_amount)
return model
def assemble_model(model_id, reread=False):
model_name = 'model%d' % model_id
# If model has already been read, just process the EKB XML
if os.path.exists(model_name + '.xml') and not reread:
tp = trips.process_xml(open(model_name + '.xml').read())
else:
# Start with the basic model
model_txt = open('model1.txt').read()
# Apply patches one by one to get to the current model text
for j in range(1, model_id):
patch_txt = open('model%d_from%d.txt' % (j+1, j)).read()
model_txt = apply_patch(model_txt, patch_txt)
print('Reading model %d text:' % model_id)
print(model_txt)
# Process model text and save result EKB XML
tp = trips.process_text(model_txt, model_name + '.xml')
print('Assembling statements:')
for i, st in enumerate(tp.statements):
print('%d: %s' % (i, st))
# Assemble the PySB model
pa = PysbAssembler()
pa.add_statements(tp.statements)
model = pa.make_model(policies='two_step')
# Set initial conditions
erk = model.monomers['ERK']
obs = Observable('ERK_p', erk(phospho='p'))
model.add_component(obs)
vem = model.monomers['VEMURAFENIB']
obs = Observable('Vem_free', vem(map3k=None))
model.add_component(obs)
ras = model.monomers['RAS']
obs = Observable('RAS_active', ras(gtp=ANY))
model.add_component(obs)
braf = model.monomers['BRAF']
obs = Observable('BRAF_active', braf(vemurafenib=None))
model.add_component(obs)
model.parameters['BRAF_0'].value = 0
egf = model.monomers['EGF']
obs = Observable('EGF_free', egf(erbb=None))
model.add_component(obs)
# Add mutated form of BRAF as initial condition
sites_dict = {}
for site in braf.sites:
if site in braf.site_states:
sites_dict[site] = braf.site_states[site][0]
else:
sites_dict[site] = None
sites_dict['V600'] = 'E'
model.add_component(Parameter('BRAF_mut_0', 1e5))
model.initial(braf(**sites_dict), model.parameters['BRAF_mut_0'])
# Set up model parameters
model.parameters['kf_ee_bind_1'].value = 1
model.parameters['kr_ee_bind_1'].value = 0.1
model.parameters['kf_ee_bind_2'].value = 1
model.parameters['kr_ee_bind_2'].value = 0.1
model.parameters['kf_eg_bind_1'].value = 1
model.parameters['kr_eg_bind_1'].value = 0.1
model.parameters['kf_gs_bind_1'].value = 1
model.parameters['kr_gs_bind_1'].value = 0.1
model.parameters['kf_sr_bind_1'].value = 1
model.parameters['kr_sr_bind_1'].value = 50
model.parameters['kf_rg_bind_1'].value = 50
model.parameters['kr_rg_bind_1'].value = 0.5
model.parameters['kf_rb_bind_1'].value = 1
model.parameters['kr_rb_bind_1'].value = 0.5
model.parameters['kf_vb_bind_1'].value = 10
model.parameters['kr_vb_bind_1'].value = 1
model.parameters['kf_bm_bind_1'].value = 1
model.parameters['kr_bm_bind_1'].value = 0.1
model.parameters['kc_bm_phosphorylation_1'].value = 3
model.parameters['kf_pm_bind_1'].value = 1
model.parameters['kr_pm_bind_1'].value = 0.001
model.parameters['kc_pm_dephosphorylation_1'].value = 10
model.parameters['kf_me_bind_1'].value = 1
model.parameters['kr_me_bind_1'].value = 0.1
model.parameters['kc_me_phosphorylation_1'].value = 10
model.parameters['kf_de_bind_1'].value = 1
model.parameters['kr_de_bind_1'].value = 0.001
model.parameters['kc_de_dephosphorylation_1'].value = 10
model.parameters['VEMURAFENIB_0'].value = 0
model.parameters['EGF_0'].value = 1e3
model.parameters['EGFR_0'].value = 1e5
model.parameters['SOS_0'].value = 1e3
model.parameters['GRB2_0'].value = 1e5
model.parameters['RAS_0'].value = 2e5
model.parameters['GTP_0'].value = 1e7
model.parameters['MEK_0'].value = 1e5
model.parameters['ERK_0'].value = 1e5
model.parameters['DUSP6_0'].value = 1e3
model.parameters['PPP2CA_0'].value = 1e5
if model_id >= 2:
model.parameters['Phosphatase_0'].value = 1e2
model.parameters['kf_es_bind_1'].value = 1e-05
model.parameters['kr_es_bind_1'].value = 1e-04
model.parameters['kc_es_phosphorylation_1'].value = 1
model.parameters['kf_ps_bind_1'].value = 1
model.parameters['kr_ps_bind_1'].value = 0.1
model.parameters['kc_ps_dephosphorylation_1'].value = 1e-04
if model_id >= 3:
model.parameters['kf_bb_bind_1'].value = 10
model.parameters['kr_bb_bind_1'].value = 1
model.parameters['kf_vb_bind_2'].value = 1e-04
pa.model = model
pa.save_model('model%d.py' % model_id)
return model
def make_bmi_model():
pa = PysbAssembler()
pa.add_statements(stmts)
model = pa.make_model()
bm = BMIModel(model, inputs=['rainfall'])
return bm
def assemble_pysb(self, stmts):
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model(policies=self.default_policy)
pa.add_default_initial_conditions(self.default_initial_amount)
return pa.model
extension = (f if f != 'pysb_flat' else 'py')
fname = 'hello_indra_model.%s' % extension
with open(fname, 'wb') as fh:
fh.write(model_export.encode('utf-8'))
# User defines text
text = 'MEK1 phosphorylates ERK2 on threonine 185 and tyrosine 187.'
# Process text using TRIPS processor
tp = trips.process_text(text)
# Get the list of extracted Statements
stmts = tp.statements
# Assemble a PySB model
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model()
# Run simulation
t = np.linspace(0, 300)
sol = Solver(pa.model, t)
sol.run()
# Plot the result
plot_result(pa.model, sol)
# Export model
export_hello(pa.model, ['sbml', 'bngl', 'kappa', 'pysb_flat'])
