variantgrid-api 0.1.4__tar.gz → 0.2.0__tar.gz

{variantgrid_api-0.1.4 → variantgrid_api-0.2.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 1.0
 Name: variantgrid_api
-Version: 0.1.4
+Version: 0.2.0
 Summary: API to connect to VariantGrid
-Home-page: https://bitbucket.org/sacgf/variantgrid_api
+Home-page: https://github.com/SACGF/vg_api
 Author: David Lawrence
 Author-email: davmlaw@gmail.com
 License: MIT License

variantgrid_api-0.2.0/README.md

@@ -0,0 +1,108 @@
+# VariantGrid API
+
+Command line tool and Python library to connect to the [Shariant](https://shariant.org.au) variant database.
+
+### Installing
+
+Install the [Pip Package](https://pypi.python.org/pypi/variantgrid_api). On Linux this is via:
+
+```
+sudo pip install variantgrid_api
+```
+
+or if you have downloaded the source code and wish to install from the local copy, run from this directory
+```
+sudo pip install -e .
+```
+
+### Command line Example
+
+Retrieve a list of classified variants
+```
+vg_api classifications --user XXX --password YYYY --all
+```
+
+### Configuration Files
+
+Create ~/.vg_api to store command line parameters so you don't have to pass them each time, eg:
+
+```
+user = XXX
+password = YYY
+```
+### Classifications (reading)
+
+Retrieve the complete set of keys that can be used in variant evidence
+```
+vg_api classifications --keys
+```
+
+Retrieve a list of classified variants
+```
+vg_api classifications --all
+```
+
+Retrieve a specific classified variant
+```
+vg_api classifications --id 5
+```
+Retrieve a specific version
+```
+vg_api classifications --id 5 --version 1
+```
+Retrieve using a lab id, where the lab id is B5886D3C-3E86-4F56-A550-1417D8AB1563
+```
+vg_api classifications --id L_B5886D3C-3E86-4F56-A550-1417D8AB1563
+```
+
+### Classifications (uploading)
+
+Inserting or replacing a record with a lab id of B5886D3C-3E86-4F56-A550-1417D8AB1563
+```
+vg_api classification_upload --id L_B5886D3C-3E86-4F56-A550-1417D8AB1563 < record_data.json
+```
+
+where the contents of record_data would look like
+```
+{
+    "condition": "OMIM:3242",
+    "BA1": "NM",
+    "age": 7,
+    etc
+}
+
+```
+
+Updating a few fields
+```
+vg_api classification_upload --method PATCH --id L_B5886D3C-3E86-4F56-A550-1417D8AB1563 < delta.json
+```
+
+### Python
+
+You can make your own API calls via Python: 
+
+
+```
+from variantgrid_api import VariantGridAPI
+
+In [1]: api = VariantGridAPI(login, password)
+
+In [2]: api.shariant_classification('4')
+Out[2]: 
+{
+    "id": 3,
+    "data": {
+        "x": {
+            "value": "y"
+        }
+    },
+    "versions": 1,
+    "version": "latest",
+    ....
+}
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

variantgrid_api-0.2.0/bin/vg_api

@@ -0,0 +1,127 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+
+from configargparse import Action, ArgParser
+from requests.exceptions import ConnectionError
+import sys
+
+from variantgrid_api.add_classification import add_classification_handle_args 
+from variantgrid_api.annotation import annotation_handle_args
+from variantgrid_api.classifications import classifications_handle_args
+from variantgrid_api.shariant_classification import shariant_classifications_handle_args
+from variantgrid_api.shariant_classification_modify import shariant_classifications_modify_handle_args
+from variantgrid_api.gene_list import gene_list_handle_args
+
+
+class ClassificationAction(Action):
+    VALID_CLASSIFICATIONS = range(1, 6)
+    def __call__(self, parser, namespace, values, option_string=None):
+        if values not in self.VALID_CLASSIFICATIONS:
+            valid_classifications_str = ','.join(map(str, self.VALID_CLASSIFICATIONS))
+            raise ValueError("classification must be one of %s" % valid_classifications_str)
+        setattr(namespace, self.dest, values)
+
+def add_authentication(parser, required):
+    parser.add("--user", required=required, env_var='VG_USER')
+    parser.add("--password", required=required, env_var='VG_PASSWORD')
+    parser.add("--basic_auth", action='store_true', env_var='VG_BASIC_AUTH', help='(Only needed for non shariant server) Set to true to just use username and password, otherwise oauth will be attempted')
+    parser.add("--oauth_url", default='https://shariant.org.au/auth/realms/agha/protocol/openid-connect/token', env_var='VG_OAUTH', help='(Only needed for non shariant server) Address of where to get the token for oauth')
+    parser.add("--client_id", default='shariant-client-tools', env_var="VG_CLIENT_ID", help='(Only needed for non shariant server) OAuth Client ID to request token against')
+
+
+def get_args():
+    # CLASSIFICATION_HELP = 'HGNC classifications: 1 - Benign, 2 - Likely benign, 3 - VUS, 4 - Likely Pathogenic, 5 - Pathogenic'
+    
+    parser = ArgParser(default_config_files=['~/.vg_api'])
+    parser.add('-c', '--config', is_config_file=True, help='config file path')
+
+    # Global settings
+
+    parser.add("--host", default='https://shariant.org.au', env_var='VG_HOST', help='Server Address (default=https://shariant.org.au)')
+    parser.add("--verbose", action='store_true', env_var='VG_VERBOSE', help='Print debugging information')
+
+    subparsers = parser.add_subparsers(help='sub-command help', dest='command')
+    
+    # Add Classification
+    # add_classification_parser = subparsers.add_parser('add_classification', help='Add new classification for a variant')
+    # add_authentication(add_classification_parser, required=True)
+    # variant_group = add_classification_parser.add_mutually_exclusive_group(required=True)
+    # variant_group.add_argument('--variant', help='hg19 coordinate eg "1:169519049 T>C"') 
+    # variant_group.add_argument('--dbsnp', help='dbSNP rsId eg "rs6025"')
+    # variant_group.add_argument('--hgvs', help='HGVS string eg "F5 (NM_000130) p.Gln534Arg/c.1601A>G"')   
+    # add_classification_parser.add_argument('--classification', type=int, action=ClassificationAction, help=CLASSIFICATION_HELP) 
+    # add_classification_parser.add_argument('--public', action='store_true', default=False, help="Classification is public (default=False)") 
+
+    classification_upload_parser = subparsers.add_parser('classification_upload', help="Create/Update a classification in Shariant")
+    add_authentication(classification_upload_parser, required=True)
+    classification_upload_parser.add_argument("--method", default="POST", help="POST or PATCH")
+    classification_upload_parser.add_argument("--id", help="Id of the record, for new record provide own id prefixed by L_ or omit")
+
+    # Classifications
+    # classifications_parser = subparsers.add_parser('classifications', help='Get classification from VariantGrid')
+    # add_authentication(classifications_parser, required=False)
+    # classifications_parser.add_argument("--classification", type=int, action=ClassificationAction)
+    # group = classifications_parser.add_mutually_exclusive_group(required=True)
+    # group.add_argument("--all", action='store_true')
+    # group.add_argument("--dbsnp")
+    # group.add_argument("--gene")
+    # group.add_argument("--locus")
+    # group.add_argument("--variant")
+
+    # Classifications
+    classifications_parser = subparsers.add_parser('classifications', help="Retrieve classifications from Shariant")
+    add_authentication(classifications_parser, required=True)
+    classifications_parser.add_argument("--version", default=None, help="Version of the record")
+    group = classifications_parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--all", action='store_true')
+    group.add_argument("--keys", action='store_true')
+    group.add_argument("--id")
+    
+    group = classifications_parser.add
+
+    # Annotation
+    annotation_parser = subparsers.add_parser('annotation', help='Get VariantGrid Annotations')
+
+    group = annotation_parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--gene-id")
+    group.add_argument("--gene")
+    group.add_argument("--variant")
+    # TODO: Annotation Versions??
+    
+    # Gene List
+    gene_list_parser = subparsers.add_parser('gene_list', help='Get Gene List')
+    add_authentication(gene_list_parser, required=False)
+    gene_list_parser.add_argument("--category", default='Uploaded', help="One of 'Diagnostic', 'Uploaded'")
+    group = gene_list_parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--pk")
+    group.add_argument("--name")
+
+    return parser.parse_args()
+
+
+def main(args):
+    SUBCOMMAND_HANDLERS = {
+        "annotation" : annotation_handle_args,
+        "add_classification" : add_classification_handle_args,
+        "classifications": shariant_classifications_handle_args,
+        "classification_upload": shariant_classifications_modify_handle_args,
+        # "classifications" : classifications_handle_args,
+        "gene_list" : gene_list_handle_args,
+    }
+    
+    handler = SUBCOMMAND_HANDLERS[args.command or '<no command given>']
+    try:
+        return handler(args)
+    except ConnectionError as nce:
+        if args.verbose:
+            msg = str(nce)
+        else:
+            msg = "Could not connect to server." 
+        print(msg, file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    args = get_args()
+    main(args)

{variantgrid_api-0.1.4 → variantgrid_api-0.2.0}/setup.py

@@ -5,14 +5,16 @@ from variantgrid_api import __version__
 setup(name='variantgrid_api',
       version=__version__,
       description='API to connect to VariantGrid',
-      url='https://bitbucket.org/sacgf/variantgrid_api',
+      url='https://github.com/SACGF/vg_api',
       author='David Lawrence',
       author_email='davmlaw@gmail.com',
       license='MIT License',
       packages=['variantgrid_api'],
       install_requires=[
-          'requests',
           'configargparse',
+          'oauthlib',
+          'requests',
+          'requests_oauthlib',
       ],
       scripts=['bin/vg_api',],
       zip_safe=False)

variantgrid_api-0.2.0/variantgrid_api/__init__.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.2.0'

{variantgrid_api-0.1.4 → variantgrid_api-0.2.0}/variantgrid_api/add_classification.py

@@ -12,5 +12,7 @@ def add_classification_handle_args(args):
     elif args.variant:
         classification = api.add_classifications_for_variant(args.variant, args.classification, args.public)
 
-        print("created classification: %s" % classification)
-
+    if classification:
+        pk = classification["id"]
+        gvc_url = "%s/variantclassification/view_genomic_variant_classification/%d" % (api.url, pk) 
+        print("Created classification: %s" % gvc_url)

variantgrid_api-0.2.0/variantgrid_api/api.py

@@ -0,0 +1,166 @@
+import json
+import logging
+import os
+import requests
+from requests_oauthlib.oauth2_auth import OAuth2
+from requests_oauthlib.oauth2_session import OAuth2Session
+from oauthlib.oauth2 import LegacyApplicationClient
+
+class VariantGridAPI(object):
+    def __init__(self,
+        user = None,
+        password = None,
+        host = 'https://shariant.org.au',
+        basic_auth = False,
+        oauth_url = 'https://shariant.org.au/auth/realms/agha/protocol/openid-connect/token',
+        client_id = 'shariant-client-tools',
+        verbose=False):
+
+        if user and password and basic_auth:
+            self.auth = (user, password)
+        elif user and password and oauth_url and client_id:
+            oauth = OAuth2Session(client=LegacyApplicationClient(client_id=client_id))
+            if verbose:
+                print(user)
+                print(password)
+                print(client_id)
+                print(oauth_url)
+            token = oauth.fetch_token(token_url=oauth_url, username=user, password=password, client_id=client_id)
+            self.auth = OAuth2(client_id = client_id, token = token)
+        else:
+            self.auth = None
+        self.host = host
+        self.verbose = verbose
+    
+    @staticmethod
+    def from_args(args):
+        return VariantGridAPI(user = args.user,
+                              password = args.password,
+                              host = args.host,
+                              basic_auth = args.basic_auth,
+                              oauth_url = args.oauth_url,
+                              client_id = args.client_id,
+                              verbose = args.verbose)
+        
+    
+    @property
+    def url(self):
+        u = "%s" % self.host
+        return u
+    
+    def get(self, path, extension = '.json'):
+        # extension defaults to .json for variantgrid methods that expect it
+        # maybe should add .json to the end of shariant methods for consistancy?
+        url_path = os.path.join(self.url, path) + extension
+        r = requests.get(url_path, auth=self.auth)
+        r.raise_for_status()
+        try:
+            return json.loads(r.text)
+        except Exception as e:
+            logging.error("Couldn't decode: %s" % r.text)
+            logging.error(e)
+        return None
+    
+    def _send(self, path, method, data):
+        url_path = os.path.join(self.url, path)
+        r = None
+        if data is not None:
+            data = json.loads(data)
+        
+        if method == 'POST':
+            r = requests.post(url_path, auth=self.auth, data=data)
+        elif method == 'PUT':
+            r = requests.put(url_path, auth=self.auth, data=data)
+        elif method == 'PATCH':
+            r = requests.patch(url_path, auth=self.auth, data=data)
+        elif method == 'DELETE':
+            r = requests.put(url_path, auth=self.auth, data=data)
+        else:
+            raise ValueError('Unsupported method ' + str(method))
+
+        r.raise_for_status()
+        try:
+            return json.loads(r.text)
+        except Exception as e:
+            logging.error("Couldn't decode: %s" % r.text)
+            logging.error(e)
+            raise e
+
+    def put(self, path, data):
+        return self._send(path, 'PUT', data)
+    
+    def patch(self, path, data):
+        return self._send(path, 'PATCH', data)
+
+    def post(self, path, data):
+        return self._send(path, 'POST', data)
+
+    def delete(self, path, data):
+        return self._send(path, 'PUT', data)
+
+    # shariant stuff below
+
+    def shariant_classification_all(self):
+        '''
+        Retrieves a list of shariant classifications the user has access to, will just provide ids
+        '''
+        return self.get('variantclassification/api/shariant/classification', extension = '')
+
+    def shariant_classification(self, record_id, version = None):
+        '''
+        Retrieves a shariant classification
+        @param record_id either number that match internal id or previously posted lab id prefixed with 'L_'
+        @param version optional, load the classification at this version (or latest if None)
+        '''
+        if version is None:
+            return self.get('variantclassification/api/shariant/classification/' + str(record_id), extension = '')
+        else:
+            return self.get('variantclassification/api/shariant/classification/' + str(record_id) + '?version=' + str(version), extension = '')
+
+    def shariant_classification_modify(self, record_id = None, method = 'POST', change = {}):
+        '''
+        Lets you update or create a shariant classification.
+        If POST, record_id can be left blank or to use an internal code prefix any string with 'L_'
+        If PATCH or PUT record_id can be it's internal id number or a previously used lab id prefixed with 'L_'
+        '''
+        #FIXME escape record_id in case it has a slash in it
+        return self._send('variantclassification/api/shariant/classification/' + str(record_id) + '?overwrite=true', method, change)
+
+    def shariant_keys(self):
+        '''
+        Returns all the currently registered key values for classification evidence and meta data about them.
+        '''
+        return self.get('variantclassification/api/shariant/keys', extension = '')
+
+
+    # variant grid stuff below
+
+    def loci_variants(self, variant_string):
+        ''' returns a list of variant objects for this loci '''
+        pass
+
+    def gene_annotation(self, ensembl_gene__id, version=None):
+        return self.get('annotation/api/gene_id/%(ensembl_gene__id)s' % {'ensembl_gene__id' : ensembl_gene__id})
+
+    def gene_annotations(self, gene_symbol, version=None):
+        ''' This may return multiple annotations for multiple genes '''
+        return self.get('annotation/api/gene/%(gene_symbol)s' % {'gene_symbol' : gene_symbol})
+
+    def variant_annotation(self, variant_string, version=None):
+        ''' variant_string can be ID, rsId, HGVS '''
+        return self.get('annotation/api/variant/%(variant_string)s' % {'variant_string' : variant_string})
+
+
+    def get_gene_list_genes(self, pk=None, category=None, name=None, version=None):
+        ''' Use either PK or both (category, name) '''
+        too_many = pk and any([category, name])
+        too_few = pk is None and not all([category, name])
+        if too_many or too_few:
+            msg = "You need to supply either 'pk' OR both ('category' AND 'name') arguments"
+            raise ValueError(msg)
+
+        if pk:
+            gene_list = self.get('snpdb/gene_list/%s' % pk)
+        else:
+            gene_list = self.get('snpdb/named_gene_list/%s/%s' % (category, name))
+        return gene_list["genelistgene_set"]

variantgrid_api-0.2.0/variantgrid_api/shariant_classification.py

@@ -0,0 +1,18 @@
+from __future__ import print_function
+import json
+
+from variantgrid_api.api import VariantGridAPI
+
+def get_classifications(args):
+    api = VariantGridAPI.from_args(args)
+
+    if args.keys:
+        return api.shariant_keys()
+    elif args.id:
+        return api.shariant_classification(args.id, args.version)
+    if args.all:
+        return api.shariant_classification_all()
+
+def shariant_classifications_handle_args(args):
+    classifications = get_classifications(args)
+    print(json.dumps(classifications))

variantgrid_api-0.2.0/variantgrid_api/shariant_classification_modify.py

@@ -0,0 +1,15 @@
+from __future__ import print_function
+import sys
+import json
+
+from variantgrid_api.api import VariantGridAPI
+
+def modify_classifications(args):
+    api = VariantGridAPI.from_args(args)
+    upload = sys.stdin.read() or {}
+    return api.shariant_classification_modify(args.id, args.method, upload)
+
+
+def shariant_classifications_modify_handle_args(args):
+    classifications = modify_classifications(args)
+    print(json.dumps(classifications))

{variantgrid_api-0.1.4 → variantgrid_api-0.2.0}/variantgrid_api.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 1.0
 Name: variantgrid-api
-Version: 0.1.4
+Version: 0.2.0
 Summary: API to connect to VariantGrid
-Home-page: https://bitbucket.org/sacgf/variantgrid_api
+Home-page: https://github.com/SACGF/vg_api
 Author: David Lawrence
 Author-email: davmlaw@gmail.com
 License: MIT License

{variantgrid_api-0.1.4 → variantgrid_api-0.2.0}/variantgrid_api.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+README.md
 setup.py
 bin/vg_api
 variantgrid_api/__init__.py
@@ -6,6 +7,8 @@ variantgrid_api/annotation.py
 variantgrid_api/api.py
 variantgrid_api/classifications.py
 variantgrid_api/gene_list.py
+variantgrid_api/shariant_classification.py
+variantgrid_api/shariant_classification_modify.py
 variantgrid_api/variant_classification_vcf.py
 variantgrid_api/vcf_utils.py
 variantgrid_api.egg-info/PKG-INFO

variantgrid_api-0.2.0/variantgrid_api.egg-info/requires.txt

@@ -0,0 +1,4 @@
+configargparse
+oauthlib
+requests
+requests_oauthlib

variantgrid_api-0.1.4/bin/vg_api

@@ -1,108 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import print_function
-
-from configargparse import Action, ArgParser
-from requests.exceptions import ConnectionError
-import sys
-
-from variantgrid_api.add_classification import add_classification_handle_args 
-from variantgrid_api.annotation import annotation_handle_args
-from variantgrid_api.classifications import classifications_handle_args
-from variantgrid_api.gene_list import gene_list_handle_args
-
-
-class ClassificationAction(Action):
-    VALID_CLASSIFICATIONS = range(1, 6)
-    def __call__(self, parser, namespace, values, option_string=None):
-        if values not in self.VALID_CLASSIFICATIONS:
-            valid_classifications_str = ','.join(map(str, self.VALID_CLASSIFICATIONS))
-            raise ValueError("classification must be one of %s" % valid_classifications_str)
-        setattr(namespace, self.dest, values)
-
-def add_authentication(parser, required):
-    parser.add("--login", required=required, env_var='VG_LOGIN')
-    parser.add("--password", required=required, env_var='VG_PASSWORD')
-
-
-def get_args():
-    CLASSIFICATION_HELP = 'HGNC classifications: 1 - Benign, 2 - Likely benign, 3 - VUS, 4 - Likely Pathogenic, 5 - Pathogenic'
-    
-    parser = ArgParser(default_config_files=['~/.vg_api'])
-    parser.add('-c', '--config', is_config_file=True, help='config file path')
-
-    # Global settings
-    parser.add("--host", default='https://variantgrid.com', env_var='VG_HOST', help='Server Address (default=https://variantgrid.com)')
-    parser.add("--port", type=int, env_var='VG_PORT', help='Server port')
-    parser.add("--verbose", default=False, action='store_true', env_var='VG_VERBOSE', help='Print debugging information')
-
-
-    subparsers = parser.add_subparsers(help='sub-command help', dest='command')
-    
-    # Add Classification
-    add_classification_parser = subparsers.add_parser('add_classification', help='Add new classification for a variant')
-    add_authentication(add_classification_parser, required=True)
-    variant_group = add_classification_parser.add_mutually_exclusive_group(required=True)
-    variant_group.add_argument('--variant', help='hg19 coordinate eg "1:169519049 T>C"') 
-    variant_group.add_argument('--dbsnp', help='dbSNP rsId eg "rs6025"')
-    variant_group.add_argument('--hgvs', help='HGVS string eg "F5 (NM_000130) p.Gln534Arg/c.1601A>G"')   
-
-
-    add_classification_parser.add_argument('--classification', type=int, action=ClassificationAction, help=CLASSIFICATION_HELP) 
-    add_classification_parser.add_argument('--public', action='store_true', default=False, help="Classification is public (default=False)") 
-
-    # Classifications
-    classifications_parser = subparsers.add_parser('classifications', help='Get classification from VariantGrid')
-    add_authentication(classifications_parser, required=False)
-    classifications_parser.add_argument("--classification", type=int, action=ClassificationAction)
-
-    group = classifications_parser.add_mutually_exclusive_group(required=True)
-    group.add_argument("--all", action='store_true')
-    group.add_argument("--dbsnp")
-    group.add_argument("--gene")
-    group.add_argument("--locus")
-    group.add_argument("--variant")
-
-    # Annotation
-    annotation_parser = subparsers.add_parser('annotation', help='Get VariantGrid Annotations')
-
-    group = annotation_parser.add_mutually_exclusive_group(required=True)
-    group.add_argument("--gene-id")
-    group.add_argument("--gene")
-    group.add_argument("--variant")
-    # TODO: Annotation Versions??
-    
-    # Gene List
-    gene_list_parser = subparsers.add_parser('gene_list', help='Get Gene List')
-    add_authentication(gene_list_parser, required=False)
-    gene_list_parser.add_argument("--category", default='Uploaded', help="One of 'Diagnostic', 'Uploaded'")
-    group = gene_list_parser.add_mutually_exclusive_group(required=True)
-    group.add_argument("--pk")
-    group.add_argument("--name")
-
-    return parser.parse_args()
-
-
-def main(args):
-    SUBCOMMAND_HANDLERS = {
-        "annotation" : annotation_handle_args,
-        "add_classification" : add_classification_handle_args,
-        "classifications" : classifications_handle_args,
-        "gene_list" : gene_list_handle_args,
-    }
-    
-    handler = SUBCOMMAND_HANDLERS[args.command]
-    try:
-        return handler(args)
-    except ConnectionError as nce:
-        if args.verbose:
-            msg = str(nce)
-        else:
-            msg = "Could not connect to server." 
-        print(msg, file=sys.stderr)
-        return 1
-
-
-if __name__ == "__main__":
-    args = get_args()
-    main(args)

variantgrid_api-0.1.4/variantgrid_api/__init__.py

@@ -1,2 +0,0 @@
-
-__version__ = '0.1.4'

variantgrid_api-0.1.4/variantgrid_api/api.py

@@ -1,125 +0,0 @@
-import json
-import logging
-import os
-import requests
-
-
-class VariantGridAPI(object):
-    def __init__(self, login=None, password=None, host='https://variantgrid.com', port=None):
-        if login and password:
-            self.auth = (login, password)
-        else:
-            self.auth = None
-        self.host = host
-        self.port = port
-    
-    @staticmethod
-    def from_args(args):
-        return VariantGridAPI(args.login,
-                              args.password,
-                              host=args.host,
-                              port=args.port)
-        
-    
-    @property
-    def url(self):
-        u = "%s" % self.host
-        if self.port:
-            u += ":%d" % self.port
-        return u
-    
-    def get(self, path):
-        url_path = os.path.join(self.url, path) + ".json"
-        r = requests.get(url_path, auth=self.auth)
-        r.raise_for_status()
-        try:
-            return json.loads(r.text)
-        except Exception as e:
-            logging.error("Couldn't decode: %s" % r.text)
-            logging.error(e)
-        return None
-    
-    def loci_variants(self, variant_string):
-        ''' returns a list of variant objects for this loci '''
-        pass
-
-    def gene_annotation(self, ensembl_gene__id, version=None):
-        return self.get('annotation/api/gene_id/%(ensembl_gene__id)s' % {'ensembl_gene__id' : ensembl_gene__id})
-
-    def gene_annotations(self, gene_symbol, version=None):
-        ''' This may return multiple annotations for multiple genes '''
-        return self.get('annotation/api/gene/%(gene_symbol)s' % {'gene_symbol' : gene_symbol})
-
-    def variant_annotation(self, variant_string, version=None):
-        ''' variant_string can be ID, rsId, HGVS '''
-        return self.get('annotation/api/variant/%(variant_string)s' % {'variant_string' : variant_string})
-
-
-    def get_gene_list_genes(self, pk=None, category=None, name=None, version=None):
-        ''' Use either PK or both (category, name) '''
-        too_many = pk and any([category, name])
-        too_few = pk is None and not all([category, name])
-        if too_many or too_few:
-            msg = "You need to supply either 'pk' OR both ('category' AND 'name') arguments"
-            raise ValueError(msg)
-
-        if pk:
-            gene_list = self.get('snpdb/gene_list/%s' % pk)
-        else:
-            gene_list = self.get('snpdb/named_gene_list/%s/%s' % (category, name))
-        return gene_list["genelistgene_set"]
-
-
-    def _get_classification_json(self, url, classification=None):
-        ''' so we can modify to stream JSON '''
-        
-        if classification:
-            url = os.path.join(url, "classification", str(classification))
-        return self.get(url)
-    
-    def variant_classifications_all(self, classification=None):
-        return self._get_classification_json('variantclassification/api/classifications/all', classification)
-    
-    def variant_classifications_for_gene(self, gene_symbol, classification=None):
-        url = 'variantclassification/api/classifications/gene/%(gene_symbol)s' % {'gene_symbol' : gene_symbol}   
-        return self._get_classification_json(url, classification)
-
-    def variant_classifications_for_dbsnp(self, dbsnp, classification=None):
-        url = 'variantclassification/api/classifications/dbsnp/%(dbsnp)s' % {'dbsnp' : dbsnp}   
-        return self._get_classification_json(url, classification)
-
-    def variant_classifications_for_locus(self, locus_string, classification=None):
-        url = 'variantclassification/api/classifications/locus/%(locus_string)s' % {'locus_string' : locus_string}   
-        return self._get_classification_json(url, classification)
-
-    def variant_classifications_for_variant(self, variant_string, classification=None):
-        url = 'variantclassification/classifications/api/variant/%(variant_string)s' % {'variant_string' : variant_string}   
-        return self._get_classification_json(url, classification)
-
-
-    def _add_classification_json(self, path, classification, public):
-        url_path = os.path.join(self.url, path) + ".json"
-        data = {"classification" : classification,
-                "public" : public}
-        
-        r = requests.post(url_path, auth=self.auth, json=data)
-        r.raise_for_status()
-        return r.text
-
-    def add_classifications_for_dbsnp(self, dbsnp, classification, public=False):
-        params = {'dbsnp' : dbsnp}
-        url = 'variantclassification/api/add_classification/dbsnp/%(dbsnp)s' % params   
-        return self._add_classification_json(url, classification, public)
-
-    def add_classifications_for_variant(self, variant_string, classification, public=False):
-        params = {'variant_string' : variant_string,}
-        url = 'variantclassification/api/add_classification/variant/%(variant_string)s' % params   
-        return self._add_classification_json(url, classification, public)
-
-
-
-    def create_variant_classification(self, variant_string, classification):
-        # Check whether the variant string is correct - get back 
-        # Send up classification
-        # Get back ID and return it
-        pass

variantgrid_api-0.1.4/variantgrid_api.egg-info/requires.txt

@@ -1,2 +0,0 @@
-requests
-configargparse