MetaGraph: metanode and metaedge getter methods

Merges #18

Add metanode and metaedge getters for convenience:

- metagraph.get_metanode
- metagraph.get_metaedge

Author: dhimmel

hetio/abbreviation.py

@@ -136,6 +136,9 @@ def metaedges_from_metapath(abbreviation, standardize_by=None):
 
 
 def metaedge_id_from_abbreviation(metagraph, abbreviation):
+    """
+    Return the metaedge_id corresponding to a metaedge abbreviation.
+    """
     source_abbrev, target_abbrev = regex.split('[a-z<>]+', abbreviation)
     edge_abbrev = regex.search('[a-z<>]+', abbreviation).group()
     abbrev_to_kind = {v: k for k, v in metagraph.kind_to_abbrev.items()}

hetio/hetnet.py

@@ -204,9 +204,36 @@ def __eq__(self, other):
 class MetaGraph(BaseGraph):
 
     def __init__(self):
-        """ """
         BaseGraph.__init__(self)
 
+    def get_metanode(self, metanode):
+        """
+        Return the metanode specified by the input, which can be either a:
+         - MetaNode (passthrough)
+         - metanode kind (str)
+         - metanode abbreviation (str)
+        """
+        if isinstance(metanode, MetaNode):
+            return metanode
+        if metanode in self.node_dict:
+            return self.get_node(metanode)
+        # Assume metanode must be an abbreviation
+        return self.get_node(self.abbrev_to_kind[metanode])
+
+    def get_metaedge(self, metaedge):
+        """
+        Return the metaedge specified by the input, which can be either a:
+         - MetaEdge (passthrough)
+         - metaedge_id (tuple)
+         - metaedge abbreviation
+        """
+        if isinstance(metaedge, MetaEdge):
+            return metaedge
+        if isinstance(metaedge, tuple):
+            return self.get_edge(metaedge)
+        metaedge_id = hetio.abbreviation.metaedge_id_from_abbreviation(self, metaedge)
+        return self.get_edge(metaedge_id)
+
     @staticmethod
     def from_edge_tuples(metaedge_tuples, kind_to_abbrev=None):
         """Create a new metagraph defined by its edges."""
@@ -231,6 +258,7 @@ def from_edge_tuples(metaedge_tuples, kind_to_abbrev=None):
     def set_abbreviations(self, kind_to_abbrev):
         """Add abbreviations as an attribute for metanodes and metaedges"""
         self.kind_to_abbrev = kind_to_abbrev
+        self.abbrev_to_kind = {v: k for k, v in kind_to_abbrev.items()}
         for kind, metanode in self.node_dict.items():
             metanode.abbrev = kind_to_abbrev[kind]
         for metaedge in self.edge_dict.values():
@@ -281,10 +309,9 @@ def extract_metapaths(self, source, target=None, max_length=4):
         the metagraph from source to target. If target is None (default), then
         metapaths to any target node are returned.
         """
-        if not isinstance(source, MetaNode):
-            source = self.node_dict[source]
-        if target and not isinstance(target, MetaNode):
-            target = self.node_dict[target]
+        source = self.get_metanode(source)
+        if target:
+            target = self.get_metanode(target)
 
         assert max_length >= 0
         if max_length == 0:

test/graph_test.py

@@ -104,13 +104,27 @@ def test_disase_gene_example():
     """
     Recreate hetnet from https://doi.org/10.1371/journal.pcbi.1004259.g002.
     """
+    metaedge_id_GaD = 'Gene', 'Disease', 'association', 'both'
     metaedge_tuples = [
-        ('Gene', 'Disease', 'association', 'both'),
+        metaedge_id_GaD,
         ('Gene', 'Tissue', 'expression', 'both'),
         ('Disease', 'Tissue', 'localization', 'both'),
         ('Gene', 'Gene', 'interaction', 'both'),
     ]
     metagraph = hetio.hetnet.MetaGraph.from_edge_tuples(metaedge_tuples)
+
+    # Test metagraph getter methods
+    gene_metanode = metagraph.node_dict['Gene']
+    assert metagraph.get_metanode(gene_metanode) == gene_metanode
+    assert metagraph.get_metanode('Gene') == gene_metanode
+    assert metagraph.get_metanode('G') == gene_metanode
+    metaedge_GaD = metagraph.get_edge(metaedge_id_GaD)
+    assert metagraph.get_metaedge(metaedge_GaD) == metaedge_GaD
+    assert metaedge_id_GaD == metaedge_GaD.get_id()
+    assert metagraph.get_metaedge(metaedge_id_GaD) == metaedge_GaD
+    assert metagraph.get_metaedge('GaD') == metaedge_GaD
+
+    # Create graph
     graph = hetio.hetnet.Graph(metagraph)
     nodes = dict()