def make_model(text):
"""Given text, return an INDRA model."""
from indra.assemblers import PysbAssembler
pa = PysbAssembler()
pa.add_statements(make_statements(text))
model = pa.make_model(policies='two_step')
return model
def assemble_pysb(stmts, data_genes, out_file):
"""Return an assembled PySB model."""
base_file, _ = os.path.splitext(out_file)
#stmts = ac.load_statements('%s.pkl' % base_file)
stmts = preprocess_stmts(stmts, data_genes)
# This is the "final" set of statements going into the assembler so it
# makes sense to cache these.
# This is also the point where index cards can be generated
ac.dump_statements(stmts, '%s_before_pa.pkl' % base_file)
assemble_index_cards(stmts, 'output/index_cards')
# Save a version of statements with no evidence for faster loading
for s in stmts:
s.evidence = []
for ss in s.supports + s.supported_by:
ss.evidence = []
ac.dump_statements(stmts, '%s_no_evidence.pkl' % base_file)
# Assemble model
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model(reverse_effects=False)
#ac.dump_statements(pa.statements, '%s_after_pa.pkl' % base_file)
# Set context
set_context(pa)
# Add observables
add_observables(pa.model)
pa.save_model(out_file)
with open('korkut_pysb.pkl', 'wb') as fh:
pickle.dump(pa.model, fh)
#pa.export_model('kappa', '%s.ka' % base_file)
return pa.model
def assemble_model(stmts):
pa = PysbAssembler(policies='one_step')
pa.add_statements(stmts)
model = pa.make_model()
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_pysb_assembler_actsub():
stmt = ActiveForm(Agent("BRAF", mutations=[MutCondition("600", "V", "E")]), "activity", True)
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model(policies="two_step")
assert len(model.rules) == 0
assert len(model.monomers) == 1
def make_model(text):
"""Given text, return an INDRA model."""
from indra.assemblers import PysbAssembler
pa = PysbAssembler()
pa.add_statements(make_statements(text))
model = pa.make_model(policies='two_step')
return model
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 test_pysb_assembler_autophos1():
enz = Agent("MEK1")
stmt = Autophosphorylation(enz, "serine", "222")
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
assert len(model.rules) == 1
assert len(model.monomers) == 1
def get_model_checker(statements):
pa = PysbAssembler()
pa.add_statements(statements)
model = pa.make_model()
stmt = Influence(Concept('crop_production'), Concept('food_security'))
mc = ModelChecker(model, [stmt])
mc.prune_influence_map()
return mc
def test_pysb_assembler_dephos_noenz():
enz = None
sub = Agent("MEK1")
stmt = Phosphorylation(enz, sub, "serine", "222")
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
assert len(model.rules) == 0
assert len(model.monomers) == 0
def test_pysb_assembler_complex1():
member1 = Agent("BRAF")
member2 = Agent("MEK1")
stmt = Complex([member1, member2])
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
assert len(model.rules) == 2
assert len(model.monomers) == 2
def assemble_model(model_indra_str):
stmts = decode_indra_stmts(model_indra_str)
pa = PysbAssembler(policies='two_step')
pa.add_statements(stmts)
model = pa.make_model()
pa.add_default_initial_conditions(100.0)
for m in model.monomers:
pysb_assembler.set_extended_initial_condition(model, m, 0)
return model
def test_pysb_assembler_rasgap1():
gap = Agent("NF1")
ras = Agent("HRAS")
stmt = RasGap(gap, "catalytic", ras)
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
print model.rules
assert len(model.rules) == 1
assert len(model.monomers) == 2
def test_activity_activity3():
subj = Agent("Vemurafenib")
obj = Agent("BRAF")
stmt = Activation(subj, None, obj, "activity", False)
pa = PysbAssembler(policies="one_step")
pa.add_statements([stmt])
model = pa.make_model()
print model.rules
assert len(model.rules) == 1
assert len(model.monomers) == 2
def test_pysb_assembler_phos2():
hras = Agent("HRAS")
enz = Agent("BRAF", bound_conditions=[BoundCondition(hras, True)])
sub = Agent("MEK1")
stmt = Phosphorylation(enz, sub, "serine", "222")
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
assert len(model.rules) == 1
assert len(model.monomers) == 3
def test_pysb_assembler_twostep_mixed():
member1 = Agent("BRAF")
member2 = Agent("RAF1")
st1 = Complex([member1, member2])
st2 = Phosphorylation(Agent("MAP2K1"), Agent("MAPK3"))
pa = PysbAssembler()
pa.add_statements([st1, st2])
pa.make_model(policies="two_step")
assert len(pa.model.rules) == 5
assert len(pa.model.monomers) == 4
def test_pysb_assembler_phos_twostep_local():
enz = Agent("BRAF")
sub = Agent("MEK1")
stmt = Phosphorylation(enz, sub, "serine", "222")
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model(policies="two_step")
print model.rules
assert len(model.rules) == 3
assert len(model.monomers) == 2
def test_pysb_assembler_autophos2():
raf1 = Agent("RAF1")
enz = Agent("MEK1", bound_conditions=[BoundCondition(raf1, True)])
stmt = Autophosphorylation(enz, "serine", "222")
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
print model.rules
assert len(model.rules) == 1
assert len(model.monomers) == 2
def test_pysb_assembler_dephos_twostep1():
phos = Agent("PP2A")
sub = Agent("MEK1")
stmt = Dephosphorylation(phos, sub, "serine", "222")
pa = PysbAssembler(policies="two_step")
pa.add_statements([stmt])
model = pa.make_model()
print model.rules
assert len(model.rules) == 3
assert len(model.monomers) == 2
def test_pysb_assembler_transphos1():
egfr = Agent("EGFR")
enz = Agent("EGFR", bound_conditions=[BoundCondition(egfr, True)])
stmt = Transphosphorylation(enz, "tyrosine")
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
print model.rules
assert len(model.rules) == 1
assert len(model.monomers) == 1
def test_activity_activity():
subj = Agent("KRAS")
obj = Agent("BRAF")
stmt = Activation(subj, "activity", obj, "activity", True)
pa = PysbAssembler(policies="interactions_only")
pa.add_statements([stmt])
model = pa.make_model()
print model.rules
assert len(model.rules) == 1
assert len(model.monomers) == 2
def test_pysb_assembler_complex_multiway():
member1 = Agent("BRAF")
member2 = Agent("MEK1")
member3 = Agent("ERK1")
stmt = Complex([member1, member2, member3])
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model(policies="multi_way")
assert len(model.rules) == 1
assert len(model.monomers) == 3
def test_set_context_monomer_notfound():
st = Phosphorylation(Agent("MAP2K1"), Agent("XYZ"))
pa = PysbAssembler()
pa.add_statements([st])
pa.make_model()
assert pa.model.parameters["MAP2K1_0"].value < 1000
assert pa.model.parameters["XYZ_0"].value < 1000
pa.set_context("A375_SKIN")
assert pa.model.parameters["MAP2K1_0"].value > 10000
assert pa.model.parameters["XYZ_0"].value < 1000
def test_mut():
mut = MutCondition("600", "V", "E")
st = Phosphorylation(Agent("BRAF", mutations=[mut]), Agent("MEK"))
pa = PysbAssembler()
pa.add_statements([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.monomer.name == "BRAF"
assert braf.site_conditions == {"V600": "E"}
def test_pysb_assembler_dephos2():
phos = Agent("PP2A")
raf1 = Agent("RAF1")
sub = Agent("MEK1", bound_conditions=[BoundCondition(raf1, True)])
stmt = Dephosphorylation(phos, sub, "serine", "222")
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
print model.rules
assert len(model.rules) == 1
assert len(model.monomers) == 3
def test_pysb_assembler_act1():
egfr = Agent("EGFR")
subj = Agent("GRB2", bound_conditions=[BoundCondition(egfr, True)])
obj = Agent("SOS1")
stmt = Activation(subj, "activity", obj, "activity", True)
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
print model.rules
assert len(model.rules) == 1
assert len(model.monomers) == 3
def test_pysb_assembler_complex3():
hras = Agent("HRAS")
member1 = Agent("BRAF", bound_conditions=[BoundCondition(hras, True)])
member2 = Agent("MEK1")
stmt = Complex([member1, member2])
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model()
print model.rules
assert len(model.rules) == 2
assert len(model.monomers) == 3
def test_neg_agent_mod():
mc = ModCondition("phosphorylation", "serine", "123", False)
st = Phosphorylation(Agent("BRAF", mods=[mc]), Agent("MAP2K2"))
pa = PysbAssembler(policies="one_step")
pa.add_statements([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.monomer.name == "BRAF"
assert braf.site_conditions == {"S123": "u"}
def test_pysb_assembler_phos_twostep_local_to_global():
enz = Agent("BRAF")
sub = Agent("MEK1")
stmt = Phosphorylation(enz, sub, "serine", "222")
pa = PysbAssembler()
pa.add_statements([stmt])
model = pa.make_model(policies="two_step")
# This call should have reverted to default policy
model = pa.make_model()
print model.rules
assert len(model.rules) == 1
assert len(model.monomers) == 2
def assemble_pysb():
"""Assemble INDRA Statements and return PySB model string."""
response = request.body.read().decode('utf-8')
body = json.loads(response)
stmts_json = body.get('statements')
stmts = stmts_from_json(stmts_json)
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model()
model_str = pa.print_model()
res = {'model': model_str}
return res
def test_unspecified_statement_policies():
enz = Agent("BRAF")
sub = Agent("MEK1")
phos = Agent("PP2A")
stmt1 = Phosphorylation(enz, sub, "serine", "222")
stmt2 = Dephosphorylation(phos, sub, "serine", "222")
policies = {"Phosphorylation": "two_step", "other": "interactions_only"}
pa = PysbAssembler(policies=policies)
pa.add_statements([stmt1, stmt2])
model = pa.make_model()
print model.rules
assert len(model.rules) == 4
assert len(model.monomers) == 3
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(policies='one_step')
pysba.add_statements([st1, st2])
model = pysba.make_model()
mps = list(pa.grounded_monomer_patterns(model, b_act))
def test_pysb_assembler_actmod2():
mek = Agent("MEK")
erk = Agent("ERK")
stmts = []
stmts.append(ActiveForm(Agent("MEK", mods=[ModCondition("phosphorylation", "serine", "218")]), "activity", True))
stmts.append(ActiveForm(Agent("MEK", mods=[ModCondition("phosphorylation", "serine", "222")]), "activity", True))
stmts.append(Phosphorylation(mek, erk, "threonine", "185"))
stmts.append(Phosphorylation(mek, erk, "tyrosine", "187"))
pa = PysbAssembler()
pa.add_statements(stmts)
model = pa.make_model()
print model.rules
assert len(model.rules) == 4
assert len(model.monomers) == 2
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 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 assemble_pysb(stmts, data_genes, out_file):
"""Return an assembled PySB model."""
stmts = ac.filter_direct(stmts)
stmts = ac.filter_belief(stmts, 0.95)
stmts = ac.filter_top_level(stmts)
stmts = ac.filter_gene_list(stmts, data_genes, 'all')
stmts = ac.reduce_activities(stmts)
pa = PysbAssembler()
pa.add_statements(stmts)
model = pa.make_model()
# Add observables
o = Observable('MAPK1p', model.monomers['MAPK1'](T185='p', Y187='p'))
model.add_component(o)
o = Observable('MAPK3p', model.monomers['MAPK3'](T202='p', Y204='p'))
model.add_component(o)
o = Observable('GSK3Ap', model.monomers['GSK3A'](S21='p'))
model.add_component(o)
o = Observable('GSK3Bp', model.monomers['GSK3B'](S9='p'))
model.add_component(o)
o = Observable('RPS6p', model.monomers['RPS6'](S235='p'))
model.add_component(o)
o = Observable('EIF4EBP1p', model.monomers['EIF4EBP1'](S65='p'))
model.add_component(o)
o = Observable('JUNp', model.monomers['JUN'](S73='p'))
model.add_component(o)
o = Observable('FOXO3p', model.monomers['FOXO3'](S315='p'))
model.add_component(o)
o = Observable('AKT1p', model.monomers['AKT1'](S473='p'))
model.add_component(o)
o = Observable('AKT2p', model.monomers['AKT2'](S474='p'))
model.add_component(o)
o = Observable('AKT3p', model.monomers['AKT3'](S='p'))
model.add_component(o)
o = Observable('ELK1', model.monomers['ELK1'](S383='p'))
model.add_component(o)
# Set context
pa.set_context('SKMEL28_SKIN')
pa.save_model(out_file)
ke = KappaExporter(model)
with open('%s.ka' % base_file, 'wb') as fh:
base_file, _ = os.path.splitext(out_file)
fh.write(ke.export().encode('utf-8'))
return model
def assemble_pysb(stmts, data_genes, out_file):
"""Return an assembled PySB model."""
base_file, _ = os.path.splitext(out_file)
#stmts = ac.load_statements('%s.pkl' % base_file)
stmts = preprocess_stmts(stmts, data_genes)
# Make a SIF model equivalent to the PySB model
# Useful for making direct comparisons in pathfinding
sa = SifAssembler(stmts)
sa.make_model(use_name_as_key=True,
include_mods=True,
include_complexes=True)
sif_str = sa.print_model(include_unsigned_edges=True)
with open('%s_pysb.sif' % base_file, 'wt') as f:
f.write(sif_str)
# This is the "final" set of statements going into the assembler so it
# makes sense to cache these.
# This is also the point where index cards can be generated
ac.dump_statements(stmts, '%s_before_pa.pkl' % base_file)
assemble_index_cards(stmts, 'output/index_cards')
# Save a version of statements with no evidence for faster loading
for s in stmts:
s.evidence = []
for ss in s.supports + s.supported_by:
ss.evidence = []
ac.dump_statements(stmts, '%s_no_evidence.pkl' % base_file)
# Assemble model
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model(reverse_effects=False)
#ac.dump_statements(pa.statements, '%s_after_pa.pkl' % base_file)
# Set context
set_context(pa)
# Add observables
add_observables(pa.model)
pa.save_model(out_file)
with open('korkut_pysb.pkl', 'wb') as fh:
pickle.dump(pa.model, fh)
#pa.export_model('kappa', '%s.ka' % base_file)
return pa.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_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 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, reread=False):
xml_fname = model_name + '.xml'
if not reread:
print('Processing %s' % xml_fname)
if os.path.exists(xml_fname):
with open(xml_fname, 'rb') as fh:
tp = trips.process_xml(fh.read())
else:
reread = True
if reread:
fname = model_name + '.txt'
print('Reading %s' % fname)
with open(fname, 'rb') as fh:
ts = time.time()
tp = trips.process_text(fh.read(), xml_fname)
te = time.time()
print('Reading took %.2fs' % (te - ts))
print('Assembling statements:')
for i, st in enumerate(tp.statements):
print('%d: %s' % (i, st))
print('----------------------')
pa = PysbAssembler()
pa.add_statements(tp.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_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(b'ERK_p', erk(phospho='p'))
model.add_component(obs)
vem = model.monomers['VEMURAFENIB']
obs = Observable(b'Vem_free', vem(map3k=None))
model.add_component(obs)
ras = model.monomers['RAS']
obs = Observable(b'RAS_active', ras(gtp=ANY))
model.add_component(obs)
braf = model.monomers['BRAF']
obs = Observable(b'BRAF_active', braf(vemurafenib=None))
model.add_component(obs)
model.parameters[b'BRAF_0'].value = 0
egf = model.monomers['EGF']
obs = Observable(b'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 assemble_pysb(self, stmts):
pa = PysbAssembler(policies=self.default_policy)
pa.add_statements(stmts)
pa.make_model()
pa.add_default_initial_conditions(self.default_initial_amount)
return pa.model
def test_save_rst():
st = Phosphorylation(Agent("MAP2K1"), Agent("MAPK3"))
pa = PysbAssembler()
pa.add_statements([st])
pa.make_model()
pa.save_rst("/dev/null")
def make_bmi_model():
pa = PysbAssembler()
pa.add_statements(stmts)
model = pa.make_model()
bm = BMIModel(model, inputs=['rainfall'])
return bm
from indra.assemblers import PysbAssembler
# 1. TEXT
# User defines text:
text = ('MEK1 phosphorylates ERK2 on threonine 185 and tyrosine 187.')
# Show round trip going out to TRIPS/DRUM web service,
# return logical form to INDRA, which is queried by
# INDRA for relevant statements
tp = trips.process_text(text)
# Now generate PySB model
stmts = tp.statements # Don't show this one
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model()
t = np.linspace(0, 25000)
sol = Solver(pa.model, t)
sol.run()
pf.set_fig_params()
plt.ion()
plt.figure(figsize=(1, 1), dpi=300)
species_names = [str(s) for s in pa.model.species]
plt.plot(t,
sol.y[:, species_names.index("MAPK1(T185='u', Y187='u')")],
'b',
label='MAPK1.uu')
plt.plot(t,
sol.y[:, species_names.index("MAPK1(T185='p', Y187='u')")] +
return mon(sdict)
def add_initial(model, pattern, value):
"""Add initial condition; if an initial condition for this pattern
already exists, override it."""
complex_pattern = pysb.as_complex_pattern(pattern)
for other_cp, other_value in model.initial_conditions:
if complex_pattern.is_equivalent_to(other_cp):
model.initial_conditions.remove((other_cp, other_value))
model.initial(complex_pattern, value)
# Generate model rules via indra
pa = PysbAssembler()
bp = bel.process_belrdf('../../data/RAS_combined.rdf')
pa.add_statements(bp.statements)
model = pa.make_model(initial_conditions=False)
# Useful shortcuts to access model components
m = model.monomers
p = model.parameters
# Add ligand to the model
model.add_component(Monomer('EGF'))
model.add_component(Parameter('kf_ee_act', 1e-6))
model.add_component(
Rule('EGF_activates_EGFR',
m['EGF']() + m['EGFR']({'Kinase':'inactive'}) >>
m['EGF']() + m['EGFR']({'Kinase':'active'}),
p['kf_ee_act']))
def assemble_pysb(stmts, data_genes, contextualize=False):
# Filter the INDRA Statements to be put into the model
stmts = ac.filter_by_type(stmts, Complex, invert=True)
stmts = ac.filter_direct(stmts)
stmts = ac.filter_belief(stmts, 0.95)
# FIXME: Consider removing to prevent mutants from superseding other stmts
stmts = ac.filter_top_level(stmts)
# Strip the extraneous supports/supported by here
strip_supports(stmts)
stmts = ac.filter_gene_list(stmts, data_genes, 'all')
stmts = ac.filter_enzyme_kinase(stmts)
stmts = ac.filter_mod_nokinase(stmts)
stmts = ac.filter_transcription_factor(stmts)
# Simplify activity types
ml = MechLinker(stmts)
ml.gather_explicit_activities()
ml.reduce_activities()
ml.gather_modifications()
ml.reduce_modifications()
stmts = normalize_active_forms(ml.statements)
# Replace activations when possible
ml = MechLinker(stmts)
ml.gather_explicit_activities()
ml.replace_activations()
# Require active forms
ml.require_active_forms()
num_stmts = len(ml.statements)
# No Modification whitelist for this use case
"""
while True:
# Remove inconsequential PTMs
ml.statements = ac.filter_inconsequential_mods(ml.statements,
get_mod_whitelist())
ml.statements = ac.filter_inconsequential_acts(ml.statements,
get_mod_whitelist())
if num_stmts <= len(ml.statements):
break
num_stmts = len(ml.statements)
"""
stmts = ml.statements
# Save the Statements here
ac.dump_statements(stmts, prefixed_pkl('pysb_stmts'))
# Add drug target Statements
#drug_target_stmts = get_drug_target_statements()
#stmts += drug_target_stmts
# Just generate the generic model
pa = PysbAssembler()
pa.add_statements(stmts)
model = pa.make_model()
with open(prefixed_pkl('pysb_model'), 'wb') as f:
pickle.dump(model, f)
# Run this extra part only if contextualize is set to True
if not contextualize:
return stmts
cell_lines_no_data = ['COLO858', 'K2', 'MMACSF', 'MZ7MEL', 'WM1552C']
for cell_line in cell_lines:
if cell_line not in cell_lines_no_data:
stmtsc = contextualize_stmts(stmts, cell_line, data_genes)
else:
stmtsc = stmts
pa = PysbAssembler()
pa.add_statements(stmtsc)
model = pa.make_model()
if cell_line not in cell_lines_no_data:
contextualize_model(model, cell_line, data_genes)
ac.dump_statements(stmtsc, prefixed_pkl('pysb_stmts_%s' % cell_line))
with open(prefixed_pkl('pysb_model_%s' % cell_line), 'wb') as f:
pickle.dump(model, f)
return stmts
from indra.assemblers import PysbAssembler
# 1. TEXT
# User defines text:
text = ('MEK1 phosphorylates ERK2 on threonine 185 and tyrosine 187.')
# Show round trip going out to TRIPS/DRUM web service,
# return logical form to INDRA, which is queried by
# INDRA for relevant statements
tp = trips.process_text(text)
# Now generate PySB model
stmts = tp.statements # Don't show this one
pa = PysbAssembler()
pa.add_statements(stmts)
pa.make_model()
t = np.linspace(0, 25000)
sol = Solver(pa.model, t)
sol.run()
pf.set_fig_params()
plt.ion()
plt.figure(figsize=(1, 1), dpi=300)
species_names = [str(s) for s in pa.model.species]
plt.plot(t, sol.y[:, species_names.index("MAPK1(T185='u', Y187='u')")],
'b', label='MAPK1.uu')
plt.plot(t, sol.y[:, species_names.index("MAPK1(T185='p', Y187='u')")] +
sol.y[:, species_names.index("MAPK1(T185='u', Y187='p')")],
'g', label='MAPK1.p')
plt.plot(t, sol.y[:, species_names.index("MAPK1(T185='p', Y187='p')")],
def test_annotation():
st = Phosphorylation(Agent("BRAF", db_refs={"UP": "P15056"}), Agent("MAP2K2", db_refs={"HGNC": "6842"}))
pa = PysbAssembler()
pa.add_statements([st])
pa.make_model()
assert len(pa.model.annotations) == 2
def add_initial(model, pattern, value):
"""Add initial condition; if an initial condition for this pattern
already exists, override it."""
complex_pattern = pysb.as_complex_pattern(pattern)
for other_cp, other_value in model.initial_conditions:
if complex_pattern.is_equivalent_to(other_cp):
model.initial_conditions.remove((other_cp, other_value))
model.initial(complex_pattern, value)
# Generate model rules via indra
pa = PysbAssembler()
bp = bel.process_belrdf('../../data/RAS_combined.rdf')
pa.add_statements(bp.statements)
model = pa.make_model(initial_conditions=False)
# Useful shortcuts to access model components
m = model.monomers
p = model.parameters
# Add ligand to the model
model.add_component(Monomer('EGF'))
model.add_component(Parameter('kf_ee_act', 1e-6))
model.add_component(
Rule(
'EGF_activates_EGFR', m['EGF']() + m['EGFR']({
'Kinase': 'inactive'
}) >> m['EGF']() + m['EGFR']({
'Kinase': 'active'
elif demo_idx == 2:
out_name_maps = [{
'atmosphere_water__rainfall_volume_flux': 'rainfall'
}, {}]
input_vars = [['rainfall'], ['flood']]
else:
out_name_maps = [{
'atmosphere_water__rainfall_volume_flux':
'Precipitation'
}]
input_vars = [['Precipitation']]
# We now assemble PySB models from the INDRA Statements and then
# instantiate these models as BMI-wrapped models along with a simulator
for idx, model_stmts in enumerate(stmts):
pa = PysbAssembler()
pa.add_statements(model_stmts)
model = pa.make_model()
if demo_idx in (1, 2):
model.name = 'indra_model%d' % idx
else:
model.name = 'indra_eval_model'
bm = BMIModel(model,
inputs=input_vars[idx],
stop_time=50000,
outside_name_map=out_name_maps[idx])
bmi_models.append(bm)
# Example 1: two NL models co-simulated
if demo_idx == 1:
# We make the model component repository without Topoflow
make_component_repo(bmi_models, False)
def assemble_model(model_name, reread=False):
xml_fname = model_name + '.xml'
if not reread:
print('Processing %s' % xml_fname)
if os.path.exists(xml_fname):
with open(xml_fname, 'rb') as fh:
tp = trips.process_xml(fh.read())
else:
reread = True
if reread:
fname = model_name + '.txt'
print('Reading %s' % fname)
with open(fname, 'rb') as fh:
tp = trips.process_text(fh.read(), xml_fname)
print('Assembling statements:')
for i, st in enumerate(tp.statements):
print('%d: %s' % (i, st))
print('----------------------')
pa = PysbAssembler()
pa.add_statements(tp.statements)
model = pa.make_model()
model.name = model_name
p53 = model.monomers['TP53']
obs = Observable(b'p53_active', p53(activity='active'))
model.add_component(obs)
if not model_name.endswith('var'):
model.parameters['kf_aa_act_1'].value = 5e-06
model.parameters['kf_pt_act_1'].value = 1e-05
if model_name == 'p53_ATM':
model.add_component(Parameter('ATMa_0', 1))
atm = model.monomers['ATM']
model.initial(atm(activity='active'), model.parameters['ATMa_0'])
model.parameters['kf_pa_act_1'].value = 1e-04
obs = Observable(b'atm_active', atm(activity='active'))
model.add_component(obs)
if model_name == 'p53_ATR':
model.add_component(Parameter('ATRa_0', 1))
atr = model.monomers['ATR']
model.initial(atr(activity='active'), model.parameters['ATRa_0'])
obs = Observable(b'atr_active', atr(activity='active'))
model.add_component(obs)
if model_name == 'p53_ATM_var':
#model.add_component(Parameter('ATMa_0', 1))
#atm = model.monomers['ATM']
#model.initial(atm(activity='active'),
# model.parameters['ATMa_0'])
model.add_component(Parameter('ATMa_0', 1))
atm = model.monomers['ATM']
model.initial(atm(phospho='p'), model.parameters['ATMa_0'])
model.parameters['kf_pa_dephosphorylation_1'].value = 1e-04
model.parameters['MDM2_0'].value = 0
model.parameters['kf_m_deg_1'].value = 8e-01
model.parameters['kf_tm_synth_1'].value = 0.2
model.parameters['kf_aa_phosphorylation_1'].value = 5e-06
obs = Observable(b'atm_active', atm(phospho='p'))
model.add_component(obs)
pa.model = model
pa.save_model('%s.py' % model_name)
return model
