Merge branch 'develop' into features/interpro

.gitlab-ci.yml

 # This file is a template, and might need editing before it works on your project.
 # Official language image. Look for the different tagged releases at:
 # https://hub.docker.com/r/library/python/tags/
-image: python:3-alpine
+image: python:3-buster
 
 # Change pip's cache directory to be inside the project directory since we can
 # only cache local items.
@@ -23,8 +23,8 @@ before_script:
   - pip install virtualenv
   - virtualenv venv
   - source venv/bin/activate
+  - apt-get install git
   - pip install -r requirements.txt
-  - apk add git
 
 stages:
   - test

dbxref/providers.yaml

@@ -66,8 +66,11 @@
   resources:
       html: ["http://rfam.xfam.org/family/%i"]
       xml: ["http://rfam.xfam.org/family/%i?content-type=text%2Fxml"]
-  # does not work
-  # check_existence: "http://rfam.xfam.org/family/%i?content-type=text%2Fxml"
+      json: ["https://rfam.org/family/%i?content-type=application/json"]
+  check_existence: "http://rfam.xfam.org/family/%i?content-type=text%2Fxml"
+  retriever:
+    type: 'internal'
+    location: 'dbxref.retrieve.rfam'
 - name: Pubmed
   prefixes: ["Pubmed"]
   resources:
@@ -119,7 +122,6 @@
       html: ["https://www.genome.jp/dbget-bin/www_bget?%i"]
       text: ["http://rest.kegg.jp/get/%i"]
   check_existence: "http://rest.kegg.jsdjkaap/get/%i"
-  # ready to use on /features/kegg branch
   retriever:
       type: 'internal'
       location: 'dbxref.retrieve.kegg'

dbxref/resolver.py

@@ -77,4 +77,8 @@ def convert_string_to_dbxref(string):
     A dbxref is dictionary with two keys: db and id.
     """
     split = string.split(':', 1)
-    return {'db': split[0], 'id': split[1]}
+    if len(split) > 1:
+      return {'db': split[0], 'id': split[1]}
+    else:
+      # invalid dbxref. nevertheless return a valid dbxref object with the value as the db and a empty id.
+      return {'db': split[0], 'id': ''}

tests/test_kegg.py

+import unittest
+from dbxref.retrieve import kegg
+
+
+class TestKegg(unittest.TestCase):
+
+    def test_output(self):
+        """Test if kegg.py gives any output"""
+        documents = kegg.retrieve([{"db": "KEGG", "id": "K00121"}], basics=True, brite=True, pathway=True,
+                                  dbxrefs_links=True, formula=True, reaction=True, genes=True, motif=True,
+                                  orthology=True, reference=True)
+        self.assertTrue(documents)
+
+    def test_brite_output_1(self):
+        # Test parsing and saving of a graph(v,e) in an adjacency list. Tree with one root and one continuous branch
+        brite_example_1 = [["BRITE       Root1"],
+                           ["             branch1"],
+                           ["              branch2"],
+                           ["               Branch3"],
+                           ["                BRANCH4"],
+                           ["                 branch5"]
+                           ]
+        brite_example_output_1 = {"vertices": ["Root1", "branch1", "branch2", "Branch3", "BRANCH4", "branch5"],
+                                  "edges": {"0": ["1"],
+                                            "1": ["2"],
+                                            "2": ["3"],
+                                            "3": ["4"],
+                                            "4": ["5"],
+                                            "5": []
+                                            }
+                                  }
+        self.assertEqual(kegg.read_brite(brite_example_1), brite_example_output_1)
+
+        # Test parsing and saving of a graph(v,e) in an adjacency list. Tree with one root but two branches.
+        brite_example_2 = [["BRITE       Root1"],
+                           ["             branch1"],
+                           ["              branch2"],
+                           ["             Branch3"],
+                           ["              BRANCH4"],
+                           ["               branch5"]
+                           ]
+        brite_example_output_2 = {"vertices": ["Root1", "branch1", "branch2", "Branch3", "BRANCH4", "branch5"],
+                                "edges": {"0": ["1", "3"],
+                                          "1": ["2"],
+                                          "2": [],
+                                          "3": ["4"],
+                                          "4": ["5"],
+                                          "5": []
+                                          }
+                                  }
+        self.assertEqual(kegg.read_brite(brite_example_2), brite_example_output_2)
+
+        # Test parsing and saving of a graph(v,e) in an adjacency list. Tree with a second root and separate branches
+        brite_example_3 = [["BRITE       Root1"],
+                           ["             branch1"],
+                           ["              branch2"],
+                           ["            Root2"],
+                           ["             BRANCH4"],
+                           ["              branch5"]
+                           ]
+        brite_example_output_3 = {"vertices": ["Root1", "branch1", "branch2", "Root2", "BRANCH4", "branch5"],
+                                  "edges": {"0": ["1"],
+                                            "1": ["2"],
+                                            "2": [],
+                                            "3": ["4"],
+                                            "4": ["5"],
+                                            "5": []
+                                            }
+                                  }
+        self.assertEqual(kegg.read_brite(brite_example_3), brite_example_output_3)
+
+        # Test parsing and saving of a graph(v,e) in an adjacency list. Tree with one root and branch, bu multiple leafs
+        brite_example_4 = [["BRITE       Root1"],
+                           ["             branch1"],
+                           ["              branch2"],
+                           ["              Branch3"],
+                           ["              BRANCH4"],
+                           ["              branch5"]
+                           ]
+        brite_example_output_4 = {"vertices": ["Root1", "branch1", "branch2", "Branch3", "BRANCH4", "branch5"],
+                                  "edges": {"0": ["1"],
+                                            "1": ["2", "3", "4", "5"],
+                                            "2": [],
+                                            "3": [],
+                                            "4": [],
+                                            "5": []
+                                            }
+                                  }
+        self.assertEqual(kegg.read_brite(brite_example_4), brite_example_output_4)
+
+        # Test parsing and saving of a graph(v,e) in an adjacency list. Tree with a mix of above testing methods
+        brite_example_5 = [["BRITE       Root1"],
+                           ["             branch1"],
+                           ["              branch2"],
+                           ["               Branch3"],
+                           ["                BRANCH4"],
+                           ["                 branch5"],
+                           ["                Branch6"],
+                           ["                Branch7"],
+                           ["              Branch8"],
+                           ["               Branch9"]
+                           ]
+        brite_example_output_5 = {"vertices": ["Root1", "branch1", "branch2", "Branch3", "BRANCH4", "branch5",
+                                               "Branch6", "Branch7", "Branch8", "Branch9"],
+                                  "edges": {"0": ["1"],
+                                            "1": ["2", "8"],
+                                            "2": ["3"],
+                                            "3": ["4", "6", "7"],
+                                            "4": ["5"],
+                                            "5": [],
+                                            "6": [],
+                                            "7": [],
+                                            "8": ["9"],
+                                            "9": []
+                                            }
+                                  }
+        self.assertEqual(kegg.read_brite(brite_example_5), brite_example_output_5)
+
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file