def require_active_forms(self):
"""Rewrites Statements with Agents' active forms in active positions.
As an example, the enzyme in a Modification Statement can be expected
to be in an active state. Similarly, subjects of RegulateAmount and
RegulateActivity Statements can be expected to be in an active form.
This function takes the collected active states of Agents in their
corresponding BaseAgents and then rewrites other Statements to apply
the active Agent states to them.
Returns
-------
new_stmts : list[indra.statements.Statement]
A list of Statements which includes the newly rewritten Statements.
This list is also set as the internal Statement list of the
MechLinker.
"""
logger.info('Setting required active forms on %d statements...' %
len(self.statements))
new_stmts = []
for stmt in self.statements:
if isinstance(stmt, Modification):
if stmt.enz is None:
new_stmts.append(stmt)
continue
enz_base = self._get_base(stmt.enz)
active_forms = enz_base.get_active_forms()
if not active_forms:
new_stmts.append(stmt)
else:
for af in active_forms:
new_stmt = fast_deepcopy(stmt)
new_stmt.uuid = str(uuid.uuid4())
evs = af.apply_to(new_stmt.enz)
new_stmt.partial_evidence = evs
new_stmts.append(new_stmt)
elif isinstance(stmt, RegulateAmount) or \
isinstance(stmt, RegulateActivity):
if stmt.subj is None:
new_stmts.append(stmt)
continue
subj_base = self._get_base(stmt.subj)
active_forms = subj_base.get_active_forms()
if not active_forms:
new_stmts.append(stmt)
else:
for af in active_forms:
new_stmt = fast_deepcopy(stmt)
new_stmt.uuid = str(uuid.uuid4())
evs = af.apply_to(new_stmt.subj)
new_stmt.partial_evidence = evs
new_stmts.append(new_stmt)
else:
new_stmts.append(stmt)
self.statements = new_stmts
return new_stmts
def require_active_forms(self):
"""Rewrites Statements with Agents' active forms in active positions.
As an example, the enzyme in a Modification Statement can be expected
to be in an active state. Similarly, subjects of RegulateAmount and
RegulateActivity Statements can be expected to be in an active form.
This function takes the collected active states of Agents in their
corresponding BaseAgents and then rewrites other Statements to apply
the active Agent states to them.
Returns
-------
new_stmts : list[indra.statements.Statement]
A list of Statements which includes the newly rewritten Statements.
This list is also set as the internal Statement list of the
MechLinker.
"""
logger.info('Setting required active forms on %d statements...' %
len(self.statements))
new_stmts = []
for stmt in self.statements:
if isinstance(stmt, Modification):
if stmt.enz is None:
new_stmts.append(stmt)
continue
enz_base = self._get_base(stmt.enz)
active_forms = enz_base.get_active_forms()
if not active_forms:
new_stmts.append(stmt)
else:
for af in active_forms:
new_stmt = fast_deepcopy(stmt)
new_stmt.uuid = str(uuid.uuid4())
evs = af.apply_to(new_stmt.enz)
new_stmt.partial_evidence = evs
new_stmts.append(new_stmt)
elif isinstance(stmt, RegulateAmount) or \
isinstance(stmt, RegulateActivity):
if stmt.subj is None:
new_stmts.append(stmt)
continue
subj_base = self._get_base(stmt.subj)
active_forms = subj_base.get_active_forms()
if not active_forms:
new_stmts.append(stmt)
else:
for af in active_forms:
new_stmt = fast_deepcopy(stmt)
new_stmt.uuid = str(uuid.uuid4())
evs = af.apply_to(new_stmt.subj)
new_stmt.partial_evidence = evs
new_stmts.append(new_stmt)
else:
new_stmts.append(stmt)
self.statements = new_stmts
return new_stmts
def __init__(self, hierarchies, stmts=None):
self.hierarchies = hierarchies
if stmts:
logger.debug("Deepcopying stmts in __init__")
self.stmts = fast_deepcopy(stmts)
else:
self.stmts = []
self.unique_stmts = None
self.related_stmts = None
def add_statements(self, stmts):
"""Add to the current list of statements.
Parameters
----------
stmts : list of :py:class:`indra.statements.Statement`
Statements to add to the current list.
"""
self.stmts += fast_deepcopy(stmts)
def add_statements(self, stmts):
"""Add to the current list of statements.
Parameters
----------
stmts : list of :py:class:`indra.statements.Statement`
Statements to add to the current list.
"""
self.stmts += fast_deepcopy(stmts)
def __init__(self, hierarchies, stmts=None):
self.hierarchies = hierarchies
if stmts:
logger.debug("Deepcopying stmts in __init__")
self.stmts = fast_deepcopy(stmts)
else:
self.stmts = []
self.unique_stmts = None
self.related_stmts = None
def flatten_evidence(stmts, collect_from=None):
"""Add evidence from *supporting* stmts to evidence for *supported* stmts.
Parameters
----------
stmts : list of :py:class:`indra.statements.Statement`
A list of top-level statements with associated supporting statements
resulting from building a statement hierarchy with
:py:meth:`combine_related`.
collect_from : str in ('supports', 'supported_by')
String indicating whether to collect and flatten evidence from the
`supports` attribute of each statement or the `supported_by` attribute.
If not set, defaults to 'supported_by'.
Returns
-------
stmts : list of :py:class:`indra.statements.Statement`
Statement hierarchy identical to the one passed, but with the
evidence lists for each statement now containing all of the evidence
associated with the statements they are supported by.
Examples
--------
Flattening evidence adds the two pieces of evidence from the supporting
statement to the evidence list of the top-level statement:
>>> from indra.preassembler.hierarchy_manager import hierarchies
>>> braf = Agent('BRAF')
>>> map2k1 = Agent('MAP2K1')
>>> st1 = Phosphorylation(braf, map2k1,
... evidence=[Evidence(text='foo'), Evidence(text='bar')])
>>> st2 = Phosphorylation(braf, map2k1, residue='S',
... evidence=[Evidence(text='baz'), Evidence(text='bak')])
>>> pa = Preassembler(hierarchies, [st1, st2])
>>> pa.combine_related() # doctest:+ELLIPSIS
[Phosphorylation(BRAF(), MAP2K1(), S)]
>>> [e.text for e in pa.related_stmts[0].evidence] # doctest:+IGNORE_UNICODE
['baz', 'bak']
>>> flattened = flatten_evidence(pa.related_stmts)
>>> sorted([e.text for e in flattened[0].evidence]) # doctest:+IGNORE_UNICODE
['bak', 'bar', 'baz', 'foo']
"""
if collect_from is None:
collect_from = 'supported_by'
if collect_from not in ('supports', 'supported_by'):
raise ValueError('collect_from must be one of "supports", '
'"supported_by"')
# Copy all of the statements--these will be the ones where we update
# the evidence lists
stmts = fast_deepcopy(stmts)
for stmt in stmts:
total_evidence = _flatten_evidence_for_stmt(stmt, collect_from)
stmt.evidence = total_evidence
return stmts
def _gather_active_forms(self):
"""Collect all the active forms of each Agent in the Statements."""
for stmt in self.statements:
if isinstance(stmt, ActiveForm):
base_agent = self.agent_set.get_create_base_agent(stmt.agent)
# Handle the case where an activity flag is set
agent_to_add = stmt.agent
if stmt.agent.activity:
new_agent = fast_deepcopy(stmt.agent)
new_agent.activity = None
agent_to_add = new_agent
base_agent.add_activity_form(agent_to_add, stmt.is_active)
def __init__(self,
hierarchies,
stmts=None,
matches_fun=None,
refinement_fun=None):
self.hierarchies = hierarchies
if stmts:
logger.debug("Deepcopying stmts in __init__")
self.stmts = fast_deepcopy(stmts)
else:
self.stmts = []
self.unique_stmts = None
self.related_stmts = None
self.matches_fun = matches_fun if matches_fun else \
default_matches_fun
self.refinement_fun = refinement_fun if refinement_fun else \
default_refinement_fun
def flatten_evidence(stmts):
"""Add evidence from *supporting* stmts to evidence for *supported* stmts.
Parameters
----------
stmts : list of :py:class:`indra.statements.Statement`
A list of top-level statements with associated supporting statements
resulting from building a statement hierarchy with
:py:meth:`combine_related`.
Returns
-------
stmts : list of :py:class:`indra.statements.Statement`
Statement hierarchy identical to the one passed, but with the
evidence lists for each statement now containing all of the evidence
associated with the statements they are supported by.
Examples
--------
Flattening evidence adds the two pieces of evidence from the supporting
statement to the evidence list of the top-level statement:
>>> from indra.preassembler.hierarchy_manager import hierarchies
>>> braf = Agent('BRAF')
>>> map2k1 = Agent('MAP2K1')
>>> st1 = Phosphorylation(braf, map2k1,
... evidence=[Evidence(text='foo'), Evidence(text='bar')])
>>> st2 = Phosphorylation(braf, map2k1, residue='S',
... evidence=[Evidence(text='baz'), Evidence(text='bak')])
>>> pa = Preassembler(hierarchies, [st1, st2])
>>> pa.combine_related() # doctest:+ELLIPSIS
[Phosphorylation(BRAF(), MAP2K1(), S)]
>>> [e.text for e in pa.related_stmts[0].evidence] # doctest:+IGNORE_UNICODE
['baz', 'bak']
>>> flattened = flatten_evidence(pa.related_stmts)
>>> sorted([e.text for e in flattened[0].evidence]) # doctest:+IGNORE_UNICODE
['bak', 'bar', 'baz', 'foo']
"""
# Copy all of the statements--these will be the ones where we update
# the evidence lists
copied_stmts = fast_deepcopy(stmts)
for stmt in stmts:
total_evidence = _flatten_evidence_for_stmt(stmt)
stmt.evidence = total_evidence
return stmts
def __init__(self,
ontology,
stmts=None,
matches_fun=None,
refinement_fun=None):
self.ontology = ontology
if stmts:
logger.debug("Deepcopying stmts in __init__")
self.stmts = fast_deepcopy(stmts)
else:
self.stmts = []
self.unique_stmts = None
self.related_stmts = None
self.matches_fun = matches_fun if matches_fun else \
default_matches_fun
self.refinement_fun = refinement_fun if refinement_fun else \
default_refinement_fun
self._comparison_counter = 0
def flatten_evidence(stmts, collect_from=None):
"""Add evidence from *supporting* stmts to evidence for *supported* stmts.
Parameters
----------
stmts : list of :py:class:`indra.statements.Statement`
A list of top-level statements with associated supporting statements
resulting from building a statement hierarchy with
:py:meth:`combine_related`.
collect_from : str in ('supports', 'supported_by')
String indicating whether to collect and flatten evidence from the
`supports` attribute of each statement or the `supported_by` attribute.
If not set, defaults to 'supported_by'.
Returns
-------
stmts : list of :py:class:`indra.statements.Statement`
Statement hierarchy identical to the one passed, but with the
evidence lists for each statement now containing all of the evidence
associated with the statements they are supported by.
Examples
--------
Flattening evidence adds the two pieces of evidence from the supporting
statement to the evidence list of the top-level statement:
>>> from indra.ontology.bio import bio_ontology
>>> braf = Agent('BRAF')
>>> map2k1 = Agent('MAP2K1')
>>> st1 = Phosphorylation(braf, map2k1,
... evidence=[Evidence(text='foo'), Evidence(text='bar')])
>>> st2 = Phosphorylation(braf, map2k1, residue='S',
... evidence=[Evidence(text='baz'), Evidence(text='bak')])
>>> pa = Preassembler(bio_ontology, [st1, st2])
>>> pa.combine_related() # doctest:+ELLIPSIS
[Phosphorylation(BRAF(), MAP2K1(), S)]
>>> [e.text for e in pa.related_stmts[0].evidence]
['baz', 'bak']
>>> flattened = flatten_evidence(pa.related_stmts)
>>> sorted([e.text for e in flattened[0].evidence])
['bak', 'bar', 'baz', 'foo']
"""
if collect_from is None:
collect_from = 'supported_by'
if collect_from not in ('supports', 'supported_by'):
raise ValueError('collect_from must be one of "supports", '
'"supported_by"')
logger.info('Flattening evidence based on %s' % collect_from)
# Copy all of the statements--these will be the ones where we update
# the evidence lists
stmts = fast_deepcopy(stmts)
for stmt in stmts:
# We get the original evidence keys here so we can differentiate them
# from ones added during flattening.
orig_ev_keys = [ev.matches_key() for ev in stmt.evidence]
# We now do the flattening
total_evidence = _flatten_evidence_for_stmt(stmt, collect_from)
# Here we add annotations for each evidence in the list,
# depending on whether it's an original direct evidence or one that
# was added during flattening
new_evidence = []
for ev in total_evidence:
ev_key = ev.matches_key()
if ev_key in orig_ev_keys:
ev.annotations['support_type'] = 'direct'
new_evidence.append(ev)
else:
ev_copy = fast_deepcopy(ev)
ev_copy.annotations['support_type'] = collect_from
new_evidence.append(ev_copy)
# Now set the new evidence list as the copied statement's evidence
stmt.evidence = new_evidence
return stmts
def flatten_evidence(stmts, collect_from=None):
"""Add evidence from *supporting* stmts to evidence for *supported* stmts.
Parameters
----------
stmts : list of :py:class:`indra.statements.Statement`
A list of top-level statements with associated supporting statements
resulting from building a statement hierarchy with
:py:meth:`combine_related`.
collect_from : str in ('supports', 'supported_by')
String indicating whether to collect and flatten evidence from the
`supports` attribute of each statement or the `supported_by` attribute.
If not set, defaults to 'supported_by'.
Returns
-------
stmts : list of :py:class:`indra.statements.Statement`
Statement hierarchy identical to the one passed, but with the
evidence lists for each statement now containing all of the evidence
associated with the statements they are supported by.
Examples
--------
Flattening evidence adds the two pieces of evidence from the supporting
statement to the evidence list of the top-level statement:
>>> from indra.preassembler.hierarchy_manager import hierarchies
>>> braf = Agent('BRAF')
>>> map2k1 = Agent('MAP2K1')
>>> st1 = Phosphorylation(braf, map2k1,
... evidence=[Evidence(text='foo'), Evidence(text='bar')])
>>> st2 = Phosphorylation(braf, map2k1, residue='S',
... evidence=[Evidence(text='baz'), Evidence(text='bak')])
>>> pa = Preassembler(hierarchies, [st1, st2])
>>> pa.combine_related() # doctest:+ELLIPSIS
[Phosphorylation(BRAF(), MAP2K1(), S)]
>>> [e.text for e in pa.related_stmts[0].evidence] # doctest:+IGNORE_UNICODE
['baz', 'bak']
>>> flattened = flatten_evidence(pa.related_stmts)
>>> sorted([e.text for e in flattened[0].evidence]) # doctest:+IGNORE_UNICODE
['bak', 'bar', 'baz', 'foo']
"""
if collect_from is None:
collect_from = 'supported_by'
if collect_from not in ('supports', 'supported_by'):
raise ValueError('collect_from must be one of "supports", '
'"supported_by"')
logger.info('Flattening evidence based on %s' % collect_from)
# Copy all of the statements--these will be the ones where we update
# the evidence lists
stmts = fast_deepcopy(stmts)
for stmt in stmts:
# We get the original evidence keys here so we can differentiate them
# from ones added during flattening.
orig_ev_keys = [ev.matches_key() for ev in stmt.evidence]
# We now do the flattening
total_evidence = _flatten_evidence_for_stmt(stmt, collect_from)
# Here we add annotations for each evidence in the list,
# depending on whether it's an original direct evidence or one that
# was added during flattening
new_evidence = []
for ev in total_evidence:
ev_key = ev.matches_key()
if ev_key in orig_ev_keys:
ev.annotations['support_type'] = 'direct'
new_evidence.append(ev)
else:
ev_copy = fast_deepcopy(ev)
ev_copy.annotations['support_type'] = collect_from
new_evidence.append(ev_copy)
# Now set the new evidence list as the copied statement's evidence
stmt.evidence = new_evidence
return stmts
def replace_activities(self):
"""Replace ative flags with Agent states when possible."""
logger.debug('Running PySB Preassembler replace activities')
# TODO: handle activity hierarchies
new_stmts = []
def has_agent_activity(stmt):
"""Return True if any agents in the Statement have activity."""
for agent in stmt.agent_list():
if isinstance(agent, Agent) and agent.activity is not None:
return True
return False
# First collect all explicit active forms
self._gather_active_forms()
# Iterate over all statements
for j, stmt in enumerate(self.statements):
logger.debug('%d/%d %s' % (j + 1, len(self.statements), stmt))
# If the Statement doesn't have any activities, we can just
# keep it and move on
if not has_agent_activity(stmt):
new_stmts.append(stmt)
continue
stmt_agents = stmt.agent_list()
num_agents = len(stmt_agents)
# Make a list with an empty list for each Agent so that later
# we can build combinations of Agent forms
agent_forms = [[] for a in stmt_agents]
for i, agent in enumerate(stmt_agents):
# This is the case where there is an activity flag on an
# Agent which we will attempt to replace with an explicit
# active form
if agent is not None and isinstance(agent, Agent) and \
agent.activity is not None:
base_agent = self.agent_set.get_create_base_agent(agent)
# If it is an "active" state
if agent.activity.is_active:
active_forms = base_agent.active_forms
# If no explicit active forms are known then we use
# the generic one
if not active_forms:
active_forms = [agent]
# If it is an "inactive" state
else:
active_forms = base_agent.inactive_forms
# If no explicit inactive forms are known then we use
# the generic one
if not active_forms:
active_forms = [agent]
# We now iterate over the active agent forms and create
# new agents
for af in active_forms:
new_agent = fast_deepcopy(agent)
self._set_agent_context(af, new_agent)
agent_forms[i].append(new_agent)
# Otherwise we just copy over the agent as is
else:
agent_forms[i].append(agent)
# Now create all possible combinations of the agents and create new
# statements as needed
agent_combs = itertools.product(*agent_forms)
for agent_comb in agent_combs:
new_stmt = fast_deepcopy(stmt)
new_stmt.set_agent_list(agent_comb)
new_stmts.append(new_stmt)
self.statements = new_stmts
