variantgrid-api 0.2.0__py2-none-any.whl

variantgrid_api/__init__.py

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

variantgrid_api/add_classification.py

@@ -0,0 +1,18 @@
+from __future__ import print_function
+
+from variantgrid_api.api import VariantGridAPI
+
+
+def add_classification_handle_args(args):
+    api = VariantGridAPI.from_args(args)
+
+    classification = None
+    if args.dbsnp:
+        classification = api.add_classifications_for_dbsnp(args.dbsnp, args.classification, args.public)
+    elif args.variant:
+        classification = api.add_classifications_for_variant(args.variant, args.classification, args.public)
+
+    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/annotation.py

@@ -0,0 +1,18 @@
+from __future__ import print_function
+
+import json
+from variantgrid_api.api import VariantGridAPI
+
+
+def annotation_handle_args(args):
+    api = VariantGridAPI.from_args(args)
+    ret = None
+    if args.gene_id:
+        ret = api.gene_annotation(args.gene_id)
+    elif args.gene:
+        ret = api.gene_annotations(args.gene)
+    elif args.variant:
+        ret = api.variant_annotation(args.variant)
+
+    print(json.dumps(ret, indent=4, sort_keys=True))
+    

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/classifications.py

@@ -0,0 +1,120 @@
+from __future__ import print_function
+
+from collections import defaultdict
+from datetime import datetime
+import variantgrid_api
+from variantgrid_api.api import VariantGridAPI
+
+from variantgrid_api.variant_classification_vcf import VARIANTCLASSIFICATION_ID, \
+    VARIANTCLASSIFICATION_ZYGOSITY, VARIANTCLASSIFICATION_GROUP, CLASSIFICATION, \
+    VARIANT_GRID_INFO_DICT, INFO_SEPARATOR
+from variantgrid_api.vcf_utils import get_vcf_header_lines, get_info
+
+
+def write_variant(classifications_for_variant):
+    # All loci should be the same
+    variant = classifications_for_variant[0]["variant"]
+    locus = variant["locus"]
+    
+    columns = [locus["chrom"],
+               locus["position"],
+               '.', # ID
+               locus["ref"],
+               variant["alt"],
+               '.', # qual
+               '.', ] # filter
+    
+    
+    MERGE_COLUMNS = {"id" : VARIANTCLASSIFICATION_ID,
+                     "zygosity" : VARIANTCLASSIFICATION_ZYGOSITY,
+                     "classification_group" : VARIANTCLASSIFICATION_GROUP,
+                     "classification_id" : CLASSIFICATION}
+    merged_columns = defaultdict(list)
+    for c in classifications_for_variant:
+        for k, info_col in MERGE_COLUMNS.items():
+            merged_columns[info_col].append(c.get(k))
+
+    info_dict = {} # "VARIANT_GRID_ID" : variant["id"]}
+    for (k, values_list) in merged_columns.items():
+        if any(values_list):
+            strings_list = map(str, [i or '' for i in values_list])
+            info_dict[k] = INFO_SEPARATOR.join(strings_list)
+    columns.append(get_info(info_dict))
+    print(*columns, sep='\t')
+    
+
+
+def get_classifications(args):
+    api = VariantGridAPI.from_args(args)
+
+    classifications = [] 
+    if args.all:
+        classifications = api.variant_classifications_all(args.classification)
+    elif args.gene:
+        classifications = api.variant_classifications_for_gene(args.gene, args.classification)
+    elif args.dbsnp:
+        classifications = api.variant_classifications_for_dbsnp(args.dbsnp, args.classification)
+    elif args.locus:
+        classifications = api.variant_classifications_for_locus(args.locus, args.classification)
+    elif args.variant:
+        classifications = api.variant_classifications_for_variant(args.variant, args.classification)
+    return classifications
+
+def get_private_command_line(args):
+    ''' private means don't show password '''
+
+    SECRET_PARAMS = ["password", "command"]
+    GLOBAL_PARAMS = ["host", "port", "login"]
+    
+    global_options_list = []
+    for p in GLOBAL_PARAMS:
+        v = getattr(args, p)
+        if v:
+            global_options_list.append("--%s=%s" % (p, v))
+
+    params = set(vars(args)) - set(SECRET_PARAMS + GLOBAL_PARAMS)
+    options_list = []
+    for p in params:
+        v = getattr(args, p)
+        if v:
+            options_list.append("--%s=%s" % (p, v))
+        
+    params = {"global_options" : ' '.join(global_options_list),
+              "command" : args.command,
+              "options" : ' '.join(options_list)}
+    return "vg_api %(global_options)s %(command)s %(options)s" % params
+
+
+def write_vcf(top_lines, classifications):
+    info_dict = VARIANT_GRID_INFO_DICT.copy()
+    
+    header_lines = get_vcf_header_lines(top_lines=top_lines, info_dict=info_dict)
+    print('\n'.join(header_lines))
+
+    # Group by variant_id
+    classifications_for_variant = []
+    last_variant_id = None
+    for classification in classifications:
+        variant_id = classification["variant"]["id"]
+        if last_variant_id and last_variant_id != variant_id: # Different
+            write_variant(classifications_for_variant)
+            classifications_for_variant = []
+
+        classifications_for_variant.append(classification)
+        last_variant_id = variant_id
+        
+    if classifications_for_variant: # leftovers
+        write_variant(classifications_for_variant)
+    
+    
+
+
+def classifications_handle_args(args):
+    classifications = get_classifications(args)
+    vg_api_str = "##generated_by=%s by vg_api v%s" % (datetime.now(), variantgrid_api.__version__)
+    command_line = "##command_line=%s" % get_private_command_line(args)
+    top_lines = [vg_api_str, command_line]
+
+    write_vcf(top_lines, classifications)
+
+    

variantgrid_api/gene_list.py

@@ -0,0 +1,15 @@
+from __future__ import print_function
+
+from variantgrid_api.api import VariantGridAPI
+
+
+def gene_list_handle_args(args):
+    api = VariantGridAPI.from_args(args)
+
+    if args.pk:
+        genes = api.get_gene_list_genes(pk=args.pk)
+    elif args.name:
+        genes = api.get_gene_list_genes(category=args.category, name=args.name)
+    
+    for gene in genes:
+        print(gene)

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/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/variant_classification_vcf.py

@@ -0,0 +1,25 @@
+INFO_SEPARATOR = '|'
+
+VARIANT_GRID_ID = 'VARIANT_GRID_ID'
+VARIANTCLASSIFICATION_ID = "VARIANTCLASSIFICATION_ID" 
+VARIANTCLASSIFICATION_ZYGOSITY = "VARIANTCLASSIFICATION_ZYGOSITY"
+VARIANTCLASSIFICATION_GROUP = "VARIANTCLASSIFICATION_GROUP"
+CLASSIFICATION = "CLASSIFICATION"
+
+MULTIPLES = " multiple values joined with a %s" % INFO_SEPARATOR
+
+VARIANT_GRID_INFO_DICT = {VARIANT_GRID_ID : {'number' : 1,
+                                             'type' : 'Integer',
+                                             'description' : 'VariantGrid primary column',},
+                          VARIANTCLASSIFICATION_ID : {'number' : 1,
+                                                      'type' : 'String',
+                                                      'description' : 'Unique Classification ID' + MULTIPLES,},
+                          VARIANTCLASSIFICATION_ZYGOSITY : {'number' : 1,
+                                                            'type' : 'String',
+                                                            'description' : 'Sample Zygosity of classification (E=HET, O=HOM)' + MULTIPLES,},
+                          VARIANTCLASSIFICATION_GROUP : {'number' : 1,
+                                                         'type' : 'String',
+                                                         'description' : 'Group performing classification' + MULTIPLES,},
+                          CLASSIFICATION : {'number' : 1,
+                                            'type' : 'String',
+                                            'description' : 'Pathogenicity according to ACMG guidelines. 1-Benign, 2-Likely Benign, 3-VUS, 4-Likely Pathogenic, 5-Pathogenic' + MULTIPLES,},}

variantgrid_api/vcf_utils.py

@@ -0,0 +1,48 @@
+'''
+Created on 13Feb.,2018
+
+@author: dlawrence
+'''
+
+
+def get_vcf_header_lines(top_lines=[], info_dict={}, formats=[], contigs=[], samples=[]):
+    ''' info_dict - values of ('number', 'type', 'description')
+        contigs - tuples of (contig, length, assembly)
+    '''
+
+    header_lines = ['##fileformat=VCFv4.1']
+    header_lines.extend(top_lines)
+    for (info_id, data) in info_dict.items():
+        data['id'] = info_id
+        line_template = '##INFO=<ID=%(id)s,Number=%(number)s,Type=%(type)s,Description="%(description)s">'
+        line = line_template % data
+        header_lines.append(line)
+
+    use_format = samples and formats 
+    if use_format:
+        header_lines.extend(formats)
+
+    for (contig, length, assembly) in contigs:
+        line = '##contig=<ID=%s,length=%d,assembly=%s>' % (contig, length, assembly)
+        header_lines.append(line)
+
+
+    colnames = ['CHROM', 'POS', 'ID', 'REF', 'ALT', 'QUAL', 'FILTER', 'INFO']
+    if use_format:
+        colnames += ['FORMAT'] + samples
+
+    header_lines.append('#' + '\t'.join(colnames))
+
+    return header_lines
+
+
+def get_info(info_dict):
+    if info_dict:
+        infos_list = []
+        for info_name, info_data in info_dict.items():
+            infos_list.append('%s=%s' % (info_name, info_data))
+        info = ';'.join(infos_list)
+    else:
+        info = '.'
+
+    return info

variantgrid_api-0.2.0.data/scripts/vg_api

@@ -0,0 +1,127 @@
+#!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.2.0.dist-info/DESCRIPTION.rst

@@ -0,0 +1,3 @@
+UNKNOWN
+
+

variantgrid_api-0.2.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.0
+Name: variantgrid-api
+Version: 0.2.0
+Summary: API to connect to VariantGrid
+Home-page: https://github.com/SACGF/vg_api
+Author: David Lawrence
+Author-email: davmlaw@gmail.com
+License: MIT License
+Platform: UNKNOWN
+Requires-Dist: configargparse
+Requires-Dist: oauthlib
+Requires-Dist: requests
+Requires-Dist: requests-oauthlib
+
+UNKNOWN
+
+

variantgrid_api-0.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+variantgrid_api/__init__.py,sha256=PWIPGZ2Gs_4sDGBGaBOXa4H_6vJzYFizkEbUm2E_aSk,23
+variantgrid_api/add_classification.py,sha256=_-42iyMN1SsnGeAtzaF59YPIHPmAauuXeXuZ0_2Esnc,667
+variantgrid_api/annotation.py,sha256=cc5YIBHjdOs42TP6EIsCEMuZF9WIXpY-zBK29lIX7WU,457
+variantgrid_api/api.py,sha256=QptZMcDFxHvrtDyveJ4tXWinh_e1h_FNA65DK2a2d8A,6638
+variantgrid_api/classifications.py,sha256=DEgdhLVv6Rn1bC4CSKnrV1mPN__1_wngzJ9eGBIDJFA,4244
+variantgrid_api/gene_list.py,sha256=AcYXT72ve-CJ7geT6lV81E0I4DSC9Tk2bj6QoNsNxbE,378
+variantgrid_api/shariant_classification.py,sha256=fe_gbfmDkwo5Yed7fLF94iQ7_fQa6FhQtRKynCmyQRc,510
+variantgrid_api/shariant_classification_modify.py,sha256=2h6x9LyTRB0g0Ho-jZTi41We2_BSK79CS6ORrijIbwo,443
+variantgrid_api/variant_classification_vcf.py,sha256=IcuzNnKeOdGSQs-5NBWDgYSDki68ZQkz8WKrB0opPxQ,1685
+variantgrid_api/vcf_utils.py,sha256=n8m3LFUCZKJUDTWh2VC-FQhmXE9m9-5bsKL6oe67rwA,1350
+variantgrid_api-0.2.0.data/scripts/vg_api,sha256=q6jzufxjesK-46t9xe7GflKzC0-K51hibWjrBaBajro,6457
+variantgrid_api-0.2.0.dist-info/DESCRIPTION.rst,sha256=OCTuuN6LcWulhHS3d5rfjdsQtW22n7HENFRh6jC6ego,10
+variantgrid_api-0.2.0.dist-info/METADATA,sha256=84G2sDXcBvzrNi1pPr9_gq4VVrWEmj30AJCJfwLzGAg,357
+variantgrid_api-0.2.0.dist-info/RECORD,,
+variantgrid_api-0.2.0.dist-info/WHEEL,sha256=hZvi-8L6mc2COqhOUWREM_h2lvnJbaHycZt8eohtmso,92
+variantgrid_api-0.2.0.dist-info/metadata.json,sha256=gIr4UIuniFCAub1nQIXhq4Sit1IkpZv4f2yLeLYveUs,533
+variantgrid_api-0.2.0.dist-info/top_level.txt,sha256=OYR1C394miMgIXa_BJxaqrS_8cA_2OZoOwzrT-zUbbM,16

variantgrid_api-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.30.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+

variantgrid_api-0.2.0.dist-info/metadata.json

@@ -0,0 +1 @@
+{"extensions": {"python.details": {"contacts": [{"email": "davmlaw@gmail.com", "name": "David Lawrence", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://github.com/SACGF/vg_api"}}}, "extras": [], "generator": "bdist_wheel (0.30.0)", "license": "MIT License", "metadata_version": "2.0", "name": "variantgrid-api", "run_requires": [{"requires": ["configargparse", "oauthlib", "requests", "requests-oauthlib"]}], "summary": "API to connect to VariantGrid", "version": "0.2.0"}

variantgrid_api-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+variantgrid_api