def test_map_sequence():
a = Agent('MAPK1', db_refs={'UP': 'P28482', 'HGNC': '6871'})
st1 = Phosphorylation(None, a, 'T', '182')
st2 = Phosphorylation(None, a, 'T', '185')
st3 = Phosphorylation(None, a, 'Y', '999')
st_out = ac.map_sequence([st1])
assert (len(st_out) == 1)
assert (st_out[0].position == '185')
st_out = ac.map_sequence([st2])
assert (len(st_out) == 1)
assert (st_out[0].position == '185')
st_out = ac.map_sequence([st3])
assert (len(st_out) == 0)
def test_map_sequence():
a = Agent('MAPK1', db_refs={'UP': 'P28482', 'HGNC': '6871'})
st1 = Phosphorylation(None, a, 'T', '182')
st2 = Phosphorylation(None, a, 'T', '185')
st3 = Phosphorylation(None, a, 'Y', '999')
st_out = ac.map_sequence([st1])
assert len(st_out) == 1, st_out
assert st_out[0].position == '185'
st_out = ac.map_sequence([st2])
assert len(st_out) == 1, st_out
assert st_out[0].position == '185'
st_out = ac.map_sequence([st3])
assert len(st_out) == 0, st_out
def _do_old_fashioned_preassembly(stmts):
grounded_stmts = ac.map_grounding(stmts,
use_adeft=True,
gilda_mode='local')
ms_stmts = ac.map_sequence(grounded_stmts, use_cache=True)
opa_stmts = ac.run_preassembly(ms_stmts, return_toplevel=False)
return opa_stmts
def respond_get_paper_model(self, content):
"""Get and display the model from a paper, indicated by pmid."""
pmid_raw = content.gets('pmid')
prefix = 'PMID-'
if pmid_raw.startswith(prefix) and pmid_raw[len(prefix):].isdigit():
pmid = pmid_raw[len(prefix):]
else:
return self.make_failure('BAD_INPUT')
try:
stmts = get_statements_for_paper([('pmid', pmid)])
except IndraDBRestAPIError as e:
if e.status_code == 404 and 'Invalid or unavailable' in e.reason:
logger.error("Could not find pmid: %s" % e.reason)
return self.make_failure('MISSING_MECHANISM')
else:
raise e
if not stmts:
resp = KQMLPerformative('SUCCESS')
resp.set('relations-found', 0)
return resp
stmts = ac.map_grounding(stmts)
stmts = ac.map_sequence(stmts)
unique_stmts = ac.run_preassembly(stmts, return_toplevel=True)
diagrams = _make_diagrams(stmts)
self.send_display_model(diagrams)
resp = KQMLPerformative('SUCCESS')
resp.set('relations-found', len(unique_stmts))
resp.set('dump-limit', str(DUMP_LIMIT))
return resp
def respond_get_paper_model(self, content):
"""Get and display the model from a paper, indicated by pmid."""
pmid_raw = content.gets('pmid')
prefix = 'PMID-'
if pmid_raw.startswith(prefix) and pmid_raw[len(prefix):].isdigit():
pmid = pmid_raw[len(prefix):]
else:
return self.make_failure('BAD_INPUT')
try:
stmts = get_statements_for_paper([('pmid', pmid)],
simple_response=True)
except IndraDBRestAPIError as e:
if e.status_code == 404 and 'Invalid or unavailable' in e.reason:
logger.error("Could not find pmid: %s" % e.reason)
return self.make_failure('MISSING_MECHANISM')
else:
raise e
if not stmts:
resp = KQMLPerformative('SUCCESS')
resp.set('relations-found', 0)
return resp
stmts = ac.map_grounding(stmts)
stmts = ac.map_sequence(stmts)
unique_stmts = ac.run_preassembly(stmts, return_toplevel=True)
diagrams = _make_diagrams(stmts)
self.send_display_model(diagrams)
resp = KQMLPerformative('SUCCESS')
resp.set('relations-found', len(unique_stmts))
resp.set('dump-limit', str(DUMP_LIMIT))
return resp
def _make_unique_statement_set(self, stmt_tpls):
"""Perform grounding, sequence mapping, and find unique set from stmts.
This method returns a list of statement objects, as well as a set of
tuples of the form (uuid, matches_key) which represent the links between
raw (evidence) statements and their unique/preassembled counterparts.
"""
stmts = []
uuid_sid_dict = {}
for sid, stmt in stmt_tpls:
uuid_sid_dict[stmt.uuid] = sid
stmts.append(stmt)
stmts = ac.map_grounding(stmts)
stmts = ac.map_sequence(stmts)
stmt_groups = self.pa._get_stmt_matching_groups(stmts)
unique_stmts = []
evidence_links = defaultdict(lambda: set())
for _, duplicates in stmt_groups:
# Get the first statement and add the evidence of all subsequent
# Statements to it
for stmt_ix, stmt in enumerate(duplicates):
if stmt_ix == 0:
first_stmt = stmt.make_generic_copy()
stmt_hash = first_stmt.get_hash(shallow=True)
evidence_links[stmt_hash].add(uuid_sid_dict[stmt.uuid])
# This should never be None or anything else
assert isinstance(first_stmt, type(stmt))
unique_stmts.append(first_stmt)
return unique_stmts, flatten_evidence_dict(evidence_links)
def run_assembly(self):
"""Run INDRA's assembly pipeline on the Statements."""
self.eliminate_copies()
stmts = self.get_indra_stmts()
stmts = self.filter_event_association(stmts)
stmts = ac.filter_no_hypothesis(stmts)
if not self.assembly_config.get('skip_map_grounding'):
stmts = ac.map_grounding(stmts)
if self.assembly_config.get('standardize_names'):
ac.standardize_names_groundings(stmts)
if self.assembly_config.get('filter_ungrounded'):
score_threshold = self.assembly_config.get('score_threshold')
stmts = ac.filter_grounded_only(stmts,
score_threshold=score_threshold)
if self.assembly_config.get('merge_groundings'):
stmts = ac.merge_groundings(stmts)
if self.assembly_config.get('merge_deltas'):
stmts = ac.merge_deltas(stmts)
relevance_policy = self.assembly_config.get('filter_relevance')
if relevance_policy:
stmts = self.filter_relevance(stmts, relevance_policy)
if not self.assembly_config.get('skip_filter_human'):
stmts = ac.filter_human_only(stmts)
if not self.assembly_config.get('skip_map_sequence'):
stmts = ac.map_sequence(stmts)
# Use WM hierarchies and belief scorer for WM preassembly
preassembly_mode = self.assembly_config.get('preassembly_mode')
if preassembly_mode == 'wm':
hierarchies = get_wm_hierarchies()
belief_scorer = get_eidos_scorer()
stmts = ac.run_preassembly(stmts,
return_toplevel=False,
belief_scorer=belief_scorer,
hierarchies=hierarchies)
else:
stmts = ac.run_preassembly(stmts, return_toplevel=False)
belief_cutoff = self.assembly_config.get('belief_cutoff')
if belief_cutoff is not None:
stmts = ac.filter_belief(stmts, belief_cutoff)
stmts = ac.filter_top_level(stmts)
if self.assembly_config.get('filter_direct'):
stmts = ac.filter_direct(stmts)
stmts = ac.filter_enzyme_kinase(stmts)
stmts = ac.filter_mod_nokinase(stmts)
stmts = ac.filter_transcription_factor(stmts)
if self.assembly_config.get('mechanism_linking'):
ml = MechLinker(stmts)
ml.gather_explicit_activities()
ml.reduce_activities()
ml.gather_modifications()
ml.reduce_modifications()
ml.gather_explicit_activities()
ml.replace_activations()
ml.require_active_forms()
stmts = ml.statements
self.assembled_stmts = stmts
def process_statements(stmts, **generate_id_map_kwargs):
stmts = ac.map_grounding(stmts)
stmts = ac.map_sequence(stmts)
pa = Preassembler(hierarchies)
unique_stmts = make_unique_statement_set(pa, stmts)
match_key_maps = get_match_key_maps(pa, unique_stmts,
**generate_id_map_kwargs)
return unique_stmts, match_key_maps
def get_omnipath_stmts():
stmts = omnipath_client.get_all_modifications()
phos_stmts = ac.filter_by_type(stmts, Phosphorylation)
dephos_stmts = ac.filter_by_type(stmts, Dephosphorylation)
stmts = phos_stmts + dephos_stmts
stmts = ac.map_sequence(stmts)
stmts = ac.filter_human_only(stmts)
#stmts = ac.filter_genes_only(stmts, specific_only=True)
return stmts
def map_sequence():
"""Map sequence on a list of INDRA Statements."""
if request.method == 'OPTIONS':
return {}
response = request.body.read().decode('utf-8')
body = json.loads(response)
stmts_json = body.get('statements')
stmts = stmts_from_json(stmts_json)
stmts_out = ac.map_sequence(stmts)
return _return_stmts(stmts_out)
def map_sequence():
"""Map sequence on a list of INDRA Statements."""
if request.method == 'OPTIONS':
return {}
response = request.body.read().decode('utf-8')
body = json.loads(response)
stmts_json = body.get('statements')
stmts = stmts_from_json(stmts_json)
stmts_out = ac.map_sequence(stmts)
return _return_stmts(stmts_out)
def run_assembly(stmts, filename):
stmts = ac.map_grounding(stmts)
stmts = ac.filter_grounded_only(stmts)
stmts = ac.filter_human_only(stmts)
#stmts = ac.expand_families(stmts)
stmts = ac.filter_gene_list(stmts, gene_names, 'one', allow_families=True)
stmts = ac.map_sequence(stmts)
stmts = ac.run_preassembly(stmts, return_toplevel=False, poolsize=4)
ac.dump_statements(stmts, filename)
return stmts
def test_readme_pipeline():
stmts = gn_stmts # Added only here, not in docs
from indra.tools import assemble_corpus as ac
stmts = ac.filter_no_hypothesis(stmts)
stmts = ac.map_grounding(stmts)
stmts = ac.filter_grounded_only(stmts)
stmts = ac.filter_human_only(stmts)
stmts = ac.map_sequence(stmts)
stmts = ac.run_preassembly(stmts, return_toplevel=False)
stmts = ac.filter_belief(stmts, 0.8)
assert stmts, 'Update example to yield statements list of non-zero length'
def _clean_statements(self, stmts):
"""Perform grounding, sequence mapping, and find unique set from stmts.
This method returns a list of statement objects, as well as a set of
tuples of the form (uuid, matches_key) which represent the links between
raw (evidence) statements and their unique/preassembled counterparts.
"""
self._log("Map grounding...")
stmts = ac.map_grounding(stmts)
self._log("Map sequences...")
stmts = ac.map_sequence(stmts, use_cache=True)
return stmts
def test_map_sequence_blank_entries():
"""Make sure sites curated as erroneous with no mappings don't
get treated as valid mappings."""
mapk1 = Agent('MAPK1', db_refs={'UP': 'P28482'})
rps6 = Agent('RPS6', db_refs={'UP': 'P62753'})
phos_rps6 = Agent('RPS6',
mods=[ModCondition('phosphorylation', 'T', '389')],
db_refs={'UP': 'P62753'})
st1 = Phosphorylation(mapk1, rps6, 'T', '389')
st2 = Phosphorylation(phos_rps6, mapk1, 'T', '185')
mapped = ac.map_sequence([st1, st2])
assert len(mapped) == 0
def preassemble(self, filters=None, grounding_map=None):
"""Preassemble the Statements collected in the model.
Use INDRA's GroundingMapper, Preassembler and BeliefEngine
on the IncrementalModel and save the unique statements and
the top level statements in class attributes.
Currently the following filter options are implemented:
- grounding: require that all Agents in statements are grounded
- human_only: require that all proteins are human proteins
- prior_one: require that at least one Agent is in the prior model
- prior_all: require that all Agents are in the prior model
Parameters
----------
filters : Optional[list[str]]
A list of filter options to apply when choosing the statements.
See description above for more details. Default: None
grounding_map : Optional[dict]
A user supplied grounding map which maps a string to a
dictionary of database IDs (in the format used by Agents'
db_refs).
"""
stmts = self.get_statements()
# Filter out hypotheses
stmts = ac.filter_no_hypothesis(stmts)
# Fix grounding
if grounding_map is not None:
stmts = ac.map_grounding(stmts, grounding_map=grounding_map)
else:
stmts = ac.map_grounding(stmts)
if filters and ('grounding' in filters):
stmts = ac.filter_grounded_only(stmts)
# Fix sites
stmts = ac.map_sequence(stmts)
if filters and 'human_only' in filters:
stmts = ac.filter_human_only(stmts)
# Run preassembly
stmts = ac.run_preassembly(stmts, return_toplevel=False)
# Run relevance filter
stmts = self._relevance_filter(stmts, filters)
# Save Statements
self.assembled_stmts = stmts
def preassemble(self, filters=None, grounding_map=None):
"""Preassemble the Statements collected in the model.
Use INDRA's GroundingMapper, Preassembler and BeliefEngine
on the IncrementalModel and save the unique statements and
the top level statements in class attributes.
Currently the following filter options are implemented:
- grounding: require that all Agents in statements are grounded
- human_only: require that all proteins are human proteins
- prior_one: require that at least one Agent is in the prior model
- prior_all: require that all Agents are in the prior model
Parameters
----------
filters : Optional[list[str]]
A list of filter options to apply when choosing the statements.
See description above for more details. Default: None
grounding_map : Optional[dict]
A user supplied grounding map which maps a string to a
dictionary of database IDs (in the format used by Agents'
db_refs).
"""
stmts = self.get_statements()
# Filter out hypotheses
stmts = ac.filter_no_hypothesis(stmts)
# Fix grounding
if grounding_map is not None:
stmts = ac.map_grounding(stmts, grounding_map=grounding_map)
else:
stmts = ac.map_grounding(stmts)
if filters and ('grounding' in filters):
stmts = ac.filter_grounded_only(stmts)
# Fix sites
stmts = ac.map_sequence(stmts)
if filters and 'human_only' in filters:
stmts = ac.filter_human_only(stmts)
# Run preassembly
stmts = ac.run_preassembly(stmts, return_toplevel=False)
# Run relevance filter
stmts = self._relevance_filter(stmts, filters)
# Save Statements
self.assembled_stmts = stmts
def map_grounding():
"""Map sequence on a list of INDRA Statements."""
response = request.body.read().decode('utf-8')
body = json.loads(response)
stmts_json = body.get('statements')
stmts = stmts_from_json(stmts_json)
stmts_out = ac.map_sequence(stmts)
if stmts_out:
stmts_json = stmts_to_json(stmts_out)
res = {'statements': stmts_json}
return res
else:
res = {'statements': []}
return res
def run_assembly(stmts, save_file):
stmts = ac.map_grounding(stmts)
stmts = ac.filter_grounded_only(stmts)
stmts = ac.filter_human_only(stmts)
stmts = ac.expand_families(stmts)
stmts = ac.filter_gene_list(stmts, gene_names, 'one')
stmts = ac.map_sequence(stmts)
stmts = ac.run_preassembly(stmts, return_toplevel=False)
stmts = ac.filter_belief(stmts, 0.95)
stmts = ac.filter_top_level(stmts)
stmts = ac.filter_direct(stmts)
stmts = ac.filter_enzyme_kinase(stmts)
ac.dump_statements(stmts, save_file)
return stmts
def run_assembly(self):
"""Run INDRA's assembly pipeline on the Statements.
Returns
-------
stmts : list[indra.statements.Statement]
The list of assembled INDRA Statements.
"""
stmts = self.get_indra_smts()
stmts = ac.filter_no_hypothesis(stmts)
stmts = ac.map_grounding(stmts)
stmts = ac.map_sequence(stmts)
stmts = ac.filter_human_only(stmts)
stmts = ac.run_preassembly(stmts, return_toplevel=False)
return stmts
def get_indra_phos_stmts():
stmts = by_gene_role_type(stmt_type='Phosphorylation')
stmts += by_gene_role_type(stmt_type='Dephosphorylation')
stmts = ac.map_grounding(stmts)
# Expand families before site mapping
stmts = ac.expand_families(stmts)
stmts = ac.filter_grounded_only(stmts)
stmts = ac.map_sequence(stmts)
ac.dump_statements(stmts, 'sources/indra_phos_sitemap.pkl')
stmts = ac.run_preassembly(stmts,
poolsize=4,
save='sources/indra_phos_stmts_pre.pkl')
stmts = ac.filter_human_only(stmts)
stmts = ac.filter_genes_only(stmts, specific_only=True)
ac.dump_statements(stmts, 'sources/indra_phos_stmts.pkl')
return stmts
def _clean_statements(self, stmts):
"""Perform grounding, sequence mapping, and find unique set from stmts.
This method returns a list of statement objects, as well as a set of
tuples of the form (uuid, matches_key) which represent the links between
raw (evidence) statements and their unique/preassembled counterparts.
"""
eliminated_uuids = {}
all_uuids = {s.uuid for s in stmts}
self._log("Map grounding...")
stmts = ac.map_grounding(stmts, use_adeft=True, gilda_mode='local')
grounded_uuids = {s.uuid for s in stmts}
eliminated_uuids['grounding'] = all_uuids - grounded_uuids
self._log("Map sequences...")
stmts = ac.map_sequence(stmts, use_cache=True)
seqmapped_and_grounded_uuids = {s.uuid for s in stmts}
eliminated_uuids['sequence mapping'] = \
grounded_uuids - seqmapped_and_grounded_uuids
return stmts, eliminated_uuids
def load_statements_from_synapse(synapse_id='syn11273504'):
syn = synapseclient.Synapse()
syn.login()
# Obtain a pointer and download the data
syn_data = syn.get(synapse_id)
stmts = []
for row in read_unicode_csv(syn_data.path, delimiter='\t'):
sub_name, site_info = row[0].split(':')
res = site_info[0]
pos = site_info[1:]
gene_list = row[1].split(',')
for enz_name in gene_list:
enz = Agent(enz_name, db_refs=get_ids(enz_name))
sub = Agent(sub_name, db_refs=get_ids(sub_name))
stmt = Phosphorylation(enz, sub, res, pos)
stmts.append(stmt)
stmts = ac.map_sequence(stmts)
stmts = ac.filter_human_only(stmts)
stmts = ac.filter_genes_only(stmts, specific_only=True)
return stmts
def run_preassembly(self, stmts, print_summary=True):
"""Run complete preassembly procedure on the given statements.
Results are returned as a dict and stored in the attribute
:py:attr:`results`. They are also saved in the pickle file
`<basename>_results.pkl`.
Parameters
----------
stmts : list of :py:class:`indra.statements.Statement`
Statements to preassemble.
print_summary : bool
If True (default), prints a summary of the preassembly process to
the console.
Returns
-------
dict
A dict containing the following entries:
- `raw`: the starting set of statements before preassembly.
- `duplicates1`: statements after initial de-duplication.
- `valid`: statements found to have valid modification sites.
- `mapped`: mapped statements (list of
:py:class:`indra.preassembler.sitemapper.MappedStatement`).
- `mapped_stmts`: combined list of valid statements and statements
after mapping.
- `duplicates2`: statements resulting from de-duplication of the
statements in `mapped_stmts`.
- `related2`: top-level statements after combining the statements
in `duplicates2`.
"""
stmts = ac.map_grounding(stmts)
stmts = ac.map_sequence(stmts)
self.results = ac.run_preassembly(stmts)
# Save the results if we're caching
if self.basename is not None:
results_filename = '%s_results.pkl' % self.basename
with open(results_filename, 'wb') as f:
pickle.dump(self.results, f)
return self.results
def pa_filter_unique_evidence(stmts):
"""Wrapper function for chaining preassembly statements meant to reduce
the number of statements.
stmts : list[:py:class:`indra.statements.Statement`]
Returns
-------
stmts : list[:py:class:`indra.statements.Statement`]
List of preassembled indra statements
"""
# Ground statemtens:
grounded_stmts = ac.map_grounding(stmts)
# Use curated site information to standardize modification sites in stmts
ms_stmts = ac.map_sequence(grounded_stmts)
# Compiles together raw statements to one statement per type
opa_stmts = ac.run_preassembly(ms_stmts, return_toplevel=False)
return opa_stmts
def test_gene_network():
# Chunk 1: this is tested in _get_gene_network_stmts
# from indra.tools.gene_network import GeneNetwork
# gn = GeneNetwork(['H2AX'])
# biopax_stmts = gn.get_biopax_stmts()
# bel_stmts = gn.get_bel_stmts()
# Chunk 2
from indra import literature
pmids = literature.pubmed_client.get_ids_for_gene('H2AX')
# Chunk 3
from indra import literature
paper_contents = {}
for pmid in pmids:
content, content_type = literature.get_full_text(pmid, 'pmid')
if content_type == 'abstract':
paper_contents[pmid] = content
if len(paper_contents) == 5: # Is 10 in actual code
break
# Chunk 4
from indra.sources import reach
literature_stmts = []
for pmid, content in paper_contents.items():
rp = reach.process_text(content, url=reach.local_text_url)
literature_stmts += rp.statements
print('Got %d statements' % len(literature_stmts))
assert literature_stmts # replaces a print statements
# Chunk 6
from indra.tools import assemble_corpus as ac
# stmts = biopax_stmts + bel_stmts + literature_stmts # tested elsewhere
stmts = gn_stmts + literature_stmts # Added instead of above line
stmts = ac.map_grounding(stmts)
stmts = ac.map_sequence(stmts)
stmts = ac.run_preassembly(stmts)
assert stmts
# Chunk 7
from indra.assemblers.cx import CxAssembler
from indra.databases import ndex_client
cxa = CxAssembler(stmts)
cx_str = cxa.make_model()
assert cx_str
# Chunk 8
# ndex_cred = {'user': '******', 'password': '******'}
# network_id = ndex_client.create_network(cx_str, ndex_cred)
# print(network_id)
# Chunk 9
from indra.assemblers.indranet import IndraNetAssembler
indranet_assembler = IndraNetAssembler(statements=stmts)
indranet = indranet_assembler.make_model()
assert len(indranet.nodes) > 0, 'indranet conatins no nodes'
assert len(indranet.edges) > 0, 'indranet conatins no edges'
# Chunk 10
import networkx as nx
paths = nx.single_source_shortest_path(G=indranet, source='H2AX', cutoff=1)
assert paths
# Chunk 11
from indra.assemblers.pysb import PysbAssembler
pysb = PysbAssembler(statements=stmts)
pysb_model = pysb.make_model()
assert pysb_model
else:
#prior_stmts = build_prior(data_genes, pjoin(outf, 'prior.pkl'))
prior_stmts = ac.load_statements(pjoin(outf, 'prior.pkl'))
prior_stmts = ac.map_grounding(prior_stmts,
save=pjoin(outf, 'gmapped_prior.pkl'))
reading_stmts = ac.load_statements(pjoin(outf, 'phase3_stmts.pkl'))
reading_stmts = ac.map_grounding(reading_stmts,
save=pjoin(outf, 'gmapped_reading.pkl'))
stmts = prior_stmts + reading_stmts
stmts = ac.filter_grounded_only(stmts)
stmts = ac.filter_genes_only(stmts, specific_only=False)
stmts = ac.filter_human_only(stmts)
stmts = ac.expand_families(stmts)
stmts = ac.filter_gene_list(stmts, data_genes, 'one')
stmts = ac.map_sequence(stmts, save=pjoin(outf, 'smapped.pkl'))
stmts = ac.run_preassembly(stmts, return_toplevel=False,
save=pjoin(outf, 'preassembled.pkl'))
assemble_models = []
assemble_models.append('sif')
assemble_models.append('pysb')
assemble_models.append('cx')
### PySB assembly
if 'pysb' in assemble_models:
pysb_model = assemble_pysb(stmts, data_genes,
pjoin(outf, 'korkut_model_pysb.py'))
### SIF assembly
if 'sif' in assemble_models:
sif_str = assemble_sif(stmts, data, pjoin(outf, 'PKN-korkut_all_ab.sif'))
# The file in which the preassembled statements will be saved
pre_stmts_file = prefixed_pkl('preassembled')
if reassemble:
# Load various files that were previously produced
sources = [
'indradb', 'trips', 'bel', 'biopax', 'phosphosite', 'r3', 'sparser'
]
stmts = []
for source in sources:
stmts += ac.load_statements(prefixed_pkl(source))
stmts = ac.filter_no_hypothesis(stmts)
# Fix grounding and filter to grounded entities and for proteins,
# filter to the human ones
stmts = ac.map_grounding(stmts)
stmts = ac.filter_grounded_only(stmts)
stmts = ac.filter_human_only(stmts)
# Combinatorially expand protein families
stmts = ac.expand_families(stmts)
# Apply a strict filter to statements based on the gene names
stmts = ac.filter_gene_list(stmts, gene_names, 'all')
# Fix errors in references to protein sequences
stmts = ac.map_sequence(stmts)
# Run preassembly and save result
stmts = ac.run_preassembly(stmts, return_toplevel=False)
ac.dump_statements(stmts, pre_stmts_file)
# Load the preassembled statements
stmts = ac.load_statements(pre_stmts_file)
# Run assembly into a PySB model
assemble_pysb.assemble_pysb(stmts, gene_names, contextualize=True)
reach_stmts = ac.load_statements(pjoin(outf, 'phase3_stmts.pkl'))
reach_stmts = ac.filter_no_hypothesis(reach_stmts)
#extra_stmts = ac.load_statements(pjoin(outf, 'extra_stmts.pkl'))
extra_stmts = read_extra_sources(pjoin(outf, 'extra_stmts.pkl'))
reading_stmts = reach_stmts + extra_stmts
reading_stmts = ac.map_grounding(reading_stmts,
save=pjoin(outf,
'gmapped_reading.pkl'))
stmts = prior_stmts + reading_stmts + extra_stmts
stmts = ac.filter_grounded_only(stmts)
stmts = ac.filter_genes_only(stmts, specific_only=False)
stmts = ac.filter_human_only(stmts)
stmts = ac.expand_families(stmts)
stmts = ac.filter_gene_list(stmts, data_genes, 'one')
stmts = ac.map_sequence(stmts, save=pjoin(outf, 'smapped.pkl'))
#stmts = ac.load_statements(pjoin(outf, 'smapped.pkl'))
stmts = ac.run_preassembly(stmts,
return_toplevel=False,
save=pjoin(outf, 'preassembled.pkl'),
poolsize=4)
### PySB assembly
if 'pysb' in assemble_models:
pysb_model = assemble_pysb(stmts, data_genes,
pjoin(outf, 'korkut_model_pysb.py'))
### SIF assembly
if 'sif' in assemble_models:
sif_str = assemble_sif(stmts, data, pjoin(outf,
'PKN-korkut_all_ab.sif'))
### CX assembly
def _do_old_fashioned_preassembly(stmts):
grounded_stmts = ac.map_grounding(stmts)
ms_stmts = ac.map_sequence(grounded_stmts)
opa_stmts = ac.run_preassembly(ms_stmts, return_toplevel=False)
return opa_stmts