Mutation¶

This module contains functions that mutate or make transformations on a network

pybel_tools.mutation.collapse_nodes(graph, survivor_mapping)[source]¶

Collapse all nodes in values to the key nodes, in place.

Parameters:	graph (pybel.BELGraph) – A BEL graph survivor_mapping (dict[tuple,set[tuple]]) – A dictionary with survivors as their keys, and iterables of the corresponding victims as values.

pybel_tools.mutation.rewire_variants_to_genes(graph)[source]¶

Finds all protein variants that are pointing to a gene and not a protein and fixes them by changing their function to be pybel.constants.GENE, in place

Parameters:	graph (pybel.BELGraph) – A BEL graph

A use case is after running collapse_to_genes().

pybel_tools.mutation.collapse_gene_variants(graph)[source]¶

Collapses all gene’s variants’ edges to their parents, in-place

Parameters:	graph (pybel.BELGraph) – A BEL graph

pybel_tools.mutation.collapse_protein_variants(graph)[source]¶

Collapses all protein’s variants’ edges to their parents, in-place

Parameters:	graph (pybel.BELGraph) – A BEL graph

pybel_tools.mutation.collapse_consistent_edges(graph)[source]¶

Collapse consistent edges together.

Warning

This operation doesn’t preserve evidences or other annotations

Parameters:	graph (pybel.BELGraph) – A BEL Graph

pybel_tools.mutation.collapse_equivalencies_by_namespace(graph, victim_namespace, survivor_namespace)[source]¶

Collapse pairs of nodes with the given namespaces that have equivalence relationships.

Parameters:	graph (pybel.BELGraph) – A BEL graph or iter[str] victim_namespace (str) – The namespace(s) of the node to collapse survivor_namespace (str) – The namespace of the node to keep

To convert all ChEBI names to InChI keys, assuming there are appropriate equivalence relations between nodes with those namespaces:

>>> collapse_equivalencies_by_namespace(graph, 'CHEBI', 'CHEBIID')
>>> collapse_equivalencies_by_namespace(graph, 'CHEBIID', 'INCHI')

pybel_tools.mutation.collapse_orthologies_by_namespace(graph, victim_namespace, survivor_namespace)[source]¶

Collapse pairs of nodes with the given namespaces that have orthology relationships.

Parameters:	graph (pybel.BELGraph) – A BEL Graph or iter[str] victim_namespace (str) – The namespace(s) of the node to collapse survivor_namespace (str) – The namespace of the node to keep

To collapse all MGI nodes to their HGNC orthologs, use: >>> collapse_orthologies_by_namespace(‘MGI’, ‘HGNC’)

To collapse collapse both MGI and RGD nodes to their HGNC orthologs, use: >>> collapse_orthologies_by_namespace([‘MGI’, ‘RGD’], ‘HGNC’)

pybel_tools.mutation.collapse_to_protein_interactions(graph)[source]¶

Collapse to a graph made of only causal gene/protein edges.

Parameters:	graph (pybel.BELGraph) – A BEL Graph
Return type:	pybel.BELGraph

pybel_tools.mutation.remove_inconsistent_edges(graph)[source]¶

Remove all edges between node paris with consistent edges.

This is the all-or-nothing approach. It would be better to do more careful investigation of the evidences during curation.

Parameters:	graph (pybel.BELGraph) – A BEL graph

pybel_tools.mutation.get_peripheral_successor_edges(graph, subgraph)[source]¶

Gets the set of possible successor edges peripheral to the subgraph. The source nodes in this iterable are all inside the subgraph, while the targets are outside.

Parameters:	graph (pybel.BELGraph) – A BEL graph subgraph – An iterator of BEL nodes
Returns:	An iterable of possible successor edges (4-tuples of node, node, key, data)
Return type:	iter[tuple]

pybel_tools.mutation.get_peripheral_predecessor_edges(graph, subgraph)[source]¶

Gets the set of possible predecessor edges peripheral to the subgraph. The target nodes in this iterable are all inside the subgraph, while the sources are outside.

Parameters:	graph (pybel.BELGraph) – A BEL graph subgraph – An iterator of BEL nodes
Returns:	An iterable on possible predecessor edges (4-tuples of node, node, key, data)
Return type:	iter[tuple]

pybel_tools.mutation.count_sources(edge_iter)[source]¶

Counts the source nodes in an edge iterator with keys and data

Parameters:	edge_iter (iter[tuple]) – An iterable on possible predecessor edges (4-tuples of node, node, key, data)
Returns:	A counter of source nodes in the iterable
Return type:	collections.Counter

pybel_tools.mutation.count_targets(edge_iter)[source]¶

Counts the target nodes in an edge iterator with keys and data

Parameters:	edge_iter (iter[tuple]) – An iterable on possible predecessor edges (4-tuples of node, node, key, data)
Returns:	A counter of target nodes in the iterable
Return type:	collections.Counter

pybel_tools.mutation.count_possible_successors(graph, subgraph)[source]¶

Parameters:	graph (pybel.BELGraph) – A BEL graph subgraph – An iterator of BEL nodes
Returns:	A counter of possible successor nodes
Return type:	collections.Counter

pybel_tools.mutation.count_possible_predecessors(graph, subgraph)[source]¶

Parameters:	graph (pybel.BELGraph) – A BEL graph subgraph – An iterator of BEL nodes
Returns:	A counter of possible predecessor nodes
Return type:	collections.Counter

pybel_tools.mutation.get_subgraph_edges(graph, annotation, value, source_filter=None, target_filter=None)[source]¶

Gets all edges from a given subgraph whose source and target nodes pass all of the given filters

Parameters:	graph (pybel.BELGraph) – A BEL graph annotation (str) – The annotation to search value (str) – The annotation value to search by source_filter – Optional filter for source nodes (graph, node) -> bool target_filter – Optional filter for target nodes (graph, node) -> bool
Returns:	An iterable of (source node, target node, key, data) for all edges that match the annotation/value and node filters
Return type:	iter[tuple]

pybel_tools.mutation.get_subgraph_peripheral_nodes(graph, subgraph, node_filters=None, edge_filters=None)[source]¶

Gets a summary dictionary of all peripheral nodes to a given subgraph

Parameters:	graph (pybel.BELGraph) – A BEL graph subgraph (iter[tuple]) – A set of nodes node_filters (lambda) – Optional. A list of node filter predicates with the interface (graph, node) -> bool. See `pybel_tools.filters.node_filters` for more information edge_filters (lambda) – Optional. A list of edge filter predicates with the interface (graph, node, node, key, data) -> bool. See `pybel_tools.filters.edge_filters` for more information
Returns:	A dictionary of {external node: {‘successor’: {internal node: list of (key, dict)}, ‘predecessor’: {internal node: list of (key, dict)}}}
Return type:	dict

For example, it might be useful to quantify the number of predecessors and successors

>>> import pybel_tools as pbt
>>> sgn = 'Blood vessel dilation subgraph'
>>> sg = pbt.selection.get_subgraph_by_annotation_value(graph, annotation='Subgraph', value=sgn)
>>> p = pbt.mutation.get_subgraph_peripheral_nodes(graph, sg, node_filters=pbt.filters.exclude_pathology_filter)
>>> for node in sorted(p, key=lambda n: len(set(p[n]['successor']) | set(p[n]['predecessor'])), reverse=True):
>>>     if 1 == len(p[sgn][node]['successor']) or 1 == len(p[sgn][node]['predecessor']):
>>>         continue
>>>     print(node,
>>>           len(p[node]['successor']),
>>>           len(p[node]['predecessor']),
>>>           len(set(p[node]['successor']) | set(p[node]['predecessor'])))

pybel_tools.mutation.expand_periphery(universe, graph, node_filters=None, edge_filters=None, threshold=2)[source]¶

Iterates over all possible edges, peripheral to a given subgraph, that could be added from the given graph. Edges could be added if they go to nodes that are involved in relationships that occur with more than the threshold (default 2) number of nodes in the subgraph.

Parameters:

universe (pybel.BELGraph) – The universe of BEL knowledge
graph (pybel.BELGraph) – The (sub)graph to expand
node_filters (lambda) – Optional. A list of node filter predicates with the interface (graph, node) -> bool. See pybel_tools.filters.node_filters for more information
edge_filters (lambda) – Optional. A list of edge filter predicates with the interface (graph, node, node, key, data) -> bool. See pybel_tools.filters.edge_filters for more information
threshold – Minimum frequency of betweenness occurrence to add a gap node

A reasonable edge filter to use is pybel_tools.filters.keep_causal_edges() because this function can allow for huge expansions if there happen to be hub nodes.

pybel_tools.mutation.enrich_grouping(universe, graph, function, relation)[source]¶

Adds all of the grouped elements. See enrich_complexes(), enrich_composites(), and enrich_reactions()

Parameters:	universe (pybel.BELGraph) – A BEL graph representing the universe of all knowledge graph (pybel.BELGraph) – The target BEL graph to enrich function (str) – The function by which the subject of each triple is filtered relation (str) – The relationship by which the predicate of each triple is filtered

pybel_tools.mutation.enrich_complexes(universe, graph)[source]¶

Add all of the members of the complex abundances to the graph.

Parameters:	universe (pybel.BELGraph) – A BEL graph representing the universe of all knowledge graph (pybel.BELGraph) – The target BEL graph to enrich

pybel_tools.mutation.enrich_composites(universe, graph)[source]¶

Adds all of the members of the composite abundances to the graph.

Parameters:	universe (pybel.BELGraph) – A BEL graph representing the universe of all knowledge graph (pybel.BELGraph) – The target BEL graph to enrich

pybel_tools.mutation.enrich_reactions(universe, graph)[source]¶

Adds all of the reactants and products of reactions to the graph.

Parameters:	universe (pybel.BELGraph) – A BEL graph representing the universe of all knowledge graph (pybel.BELGraph) – The target BEL graph to enrich

pybel_tools.mutation.enrich_variants(universe, graph, func=None)[source]¶

Add the reference nodes for all variants of the given function.

Parameters:	universe (pybel.BELGraph) – A BEL graph representing the universe of all knowledge graph (pybel.BELGraph) – The target BEL graph to enrich or iter[str] func (str) – The function by which the subject of each triple is filtered. Defaults to the set of protein, rna, mirna, and gene.

pybel_tools.mutation.enrich_unqualified(universe, graph)[source]¶

Enrich the subgraph with the unqualified edges from the graph.

Parameters:	universe (pybel.BELGraph) – A BEL graph representing the universe of all knowledge graph (pybel.BELGraph) – The target BEL graph to enrich

The reason you might want to do this is you induce a subgraph from the original graph based on an annotation filter, but the unqualified edges that don’t have annotations that most likely connect elements within your graph are not included.

See also

This function thinly wraps the successive application of the following functions:

enrich_complexes()
enrich_composites()
enrich_reactions()
enrich_variants()

Equivalent to:

>>> enrich_complexes(universe, graph)
>>> enrich_composites(universe, graph)
>>> enrich_reactions(universe, graph)
>>> enrich_variants(universe, graph)

pybel_tools.mutation.expand_internal(universe, graph, edge_filters=None)[source]¶

Edges between entities in the subgraph that pass the given filters

Parameters:	universe (pybel.BELGraph) – The full graph graph (pybel.BELGraph) – A subgraph to find the upstream information edge_filters (list or lambda) – Optional list of edge filter functions (graph, node, node, key, data) -> bool

pybel_tools.mutation.expand_internal_causal(universe, graph)[source]¶

Adds causal edges between entities in the subgraph.

Is an extremely thin wrapper around expand_internal().

Parameters:	universe (pybel.BELGraph) – A BEL graph representing the universe of all knowledge graph (pybel.BELGraph) – The target BEL graph to enrich with causal relations between contained nodes

Equivalent to:

>>> import pybel_tools as pbt
>>> from pybel.struct.filters.edge_predicates import is_causal_relation
>>> pbt.mutation.expand_internal(universe, graph, edge_filters=is_causal_relation)

pybel_tools.mutation.is_node_highlighted(graph, node)[source]¶

Returns if the given node is highlighted.

Parameters:	graph (pybel.BELGraph) – A BEL graph node (tuple) – A BEL node
Returns:	Does the node contain highlight information?
Return type:	bool

pybel_tools.mutation.highlight_nodes(graph, nodes=None, color=None)[source]¶

Adds a highlight tag to the given nodes.

Parameters:	graph (pybel.BELGraph) – A BEL graph nodes (iter[tuple]) – The nodes to add a highlight tag on color (str) – The color to highlight (use something that works with CSS)

pybel_tools.mutation.remove_highlight_nodes(graph, nodes=None)[source]¶

Removes the highlight from the given nodes, or all nodes if none given.

Parameters:	graph (pybel.BELGraph) – A BEL graph nodes (list) – The list of nodes to un-highlight

pybel_tools.mutation.is_edge_highlighted(graph, u, v, k, d)[source]¶

Returns if the given edge is highlighted.

Parameters:	graph (pybel.BELGraph) – A BEL graph
Returns:	Does the edge contain highlight information?
Return type:	bool

pybel_tools.mutation.highlight_edges(graph, edges=None, color=None)[source]¶

Adds a highlight tag to the given edges.

Parameters:	graph (pybel.BELGraph) – A BEL graph edges (iter[tuple]) – The edges (4-tuples of u, v, k, d) to add a highlight tag on color (str) – The color to highlight (use something that works with CSS)

pybel_tools.mutation.remove_highlight_edges(graph, edges=None)[source]¶

Removes the highlight from the given edges, or all edges if none given.

Parameters:	graph (pybel.BELGraph) – A BEL graph edges (iter[tuple]) – The edges (4-tuple of u,v,k,d) to remove the highlight from)

pybel_tools.mutation.highlight_subgraph(universe, graph)[source]¶

Highlights all nodes/edges in the universe that in the given graph.

Parameters:	universe (pybel.BELGraph) – The universe of knowledge

pybel_tools.mutation.remove_highlight_subgraph(graph, subgraph)[source]¶

Removes the highlight from all nodes/edges in the graph that are in the subgraph.

Parameters:	graph (pybel.BELGraph) – The BEL graph to mutate subgraph (pybel.BELGraph) – The subgraph from which to remove the highlighting

pybel_tools.mutation.enrich_protein_and_rna_origins(graph)[source]¶

Add the corresponding RNA for each protein then the corresponding gene for each RNA/miRNA.

Parameters:	graph (pybel.BELGraph) – A BEL graph

pybel_tools.mutation.infer_missing_two_way_edges(graph)[source]¶

Add edges to the graph when a two way edge exists, and the opposite direction doesn’t exist.

Use: two way edges from BEL definition and/or axiomatic inverses of membership relations

Parameters:	graph (pybel.BELGraph) – A BEL graph

pybel_tools.mutation.infer_missing_backwards_edge(graph, u, v, k)[source]¶

Add the same edge, but in the opposite direction if not already present.

pybel_tools.mutation.enrich_internal_unqualified_edges(graph, subgraph)[source]¶

Add the missing unqualified edges between entities in the subgraph that are contained within the full graph.

Parameters:	graph (pybel.BELGraph) – The full BEL graph subgraph (pybel.BELGraph) – The query BEL subgraph

pybel_tools.mutation.parse_authors(graph, force_parse=False)[source]¶

Parses all of the citation author strings to lists by splitting on the pipe character “|”

Parameters:	graph (pybel.BELGraph) – A BEL graph force_parse (bool) – Forces serialization without checking the tag
Returns:	A set of all authors in this graph
Return type:	set[str]

pybel_tools.mutation.serialize_authors(graph, force_serialize=False)[source]¶

Recombines all authors with the pipe character “|”.

Parameters:	graph (pybel.BELGraph) – A BEL graph force_serialize (bool) – Forces serialization without checking the tag

pybel_tools.mutation.enrich_pubmed_citations(graph, stringify_authors=False, manager=None)[source]¶

Overwrites all PubMed citations with values from NCBI’s eUtils lookup service.

Sets authors as list, so probably a good idea to run pybel_tools.mutation.serialize_authors() before exporting.

Parameters:	graph (pybel.BELGraph) – A BEL graph stringify_authors (bool) – Converts all author lists to author strings using `pybel_tools.mutation.serialize_authors()`. Defaults to `False`. manager (None or str or Manager) – An RFC-1738 database connection string, a pre-built `pybel.manager.Manager`, or `None` for default connection
Returns:	A set of PMIDs for which the eUtils service crashed
Return type:	set[str]

pybel_tools.mutation.random_by_nodes(graph, percentage=None)[source]¶

Gets a random graph by inducing over a percentage of the original nodes

Parameters:	graph (pybel.BELGraph) – A BEL graph percentage (float) – The percentage of edges to keep
Return type:	pybel.BELGraph

pybel_tools.mutation.random_by_edges(graph, percentage=None)[source]¶

Gets a random graph by keeping a certain percentage of original edges

Parameters:	graph (pybel.BELGraph) – A BEL graph percentage (float) – The percentage of edges to keep
Return type:	pybel.BELGraph

pybel_tools.mutation.shuffle_node_data(graph, key, percentage=None)[source]¶

Shuffles the node’s data. Useful for permutation testing.

Parameters:	graph (pybel.BELGraph) – A BEL graph key (str) – The node data dictionary key percentage (float) – What percentage of possible swaps to make
Return type:	pybel.BELGraph

pybel_tools.mutation.shuffle_relations(graph, percentage=None)[source]¶

Shuffles the relations. Useful for permutation testing.

Parameters:	graph (pybel.BELGraph) – A BEL graph percentage (float) – What percentage of possible swaps to make
Return type:	pybel.BELGraph

pybel_tools.mutation.build_expand_node_neighborhood_by_hash(manager: pybel.manager.cache_manager.Manager)[source]¶

Make an expand function that’s bound to the manager.

Return type:	(pybel.BELGraph, pybel.BELGraph, str) -> None

pybel_tools.mutation.build_delete_node_by_hash(manager: pybel.manager.cache_manager.Manager)[source]¶

Make a delete function that’s bound to the manager.

Return type:	(pybel.BELGraph, str) -> None