variantgrid-api 0.0.2__tar.gz

variantgrid_api-0.0.2/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: variantgrid_api
+Version: 0.0.2
+Summary: API to connect to VariantGrid
+Home-page: https://bitbucket.org/sacgf/variantgrid_api
+Author: David Lawrence
+Author-email: davmlaw@gmail.com
+License: MIT License
+Description: UNKNOWN
+Platform: UNKNOWN

variantgrid_api-0.0.2/bin/vg_api

@@ -0,0 +1,108 @@
+#!/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.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

variantgrid_api-0.0.2/setup.py

@@ -0,0 +1,18 @@
+from __future__ import absolute_import 
+from setuptools import setup
+from variantgrid_api import __version__
+
+setup(name='variantgrid_api',
+      version=__version__,
+      description='API to connect to VariantGrid',
+      url='https://bitbucket.org/sacgf/variantgrid_api',
+      author='David Lawrence',
+      author_email='davmlaw@gmail.com',
+      license='MIT License',
+      packages=['variantgrid_api'],
+      install_requires=[
+          'requests',
+          'configargparse',
+      ],
+      scripts=['bin/vg_api',],
+      zip_safe=False)

variantgrid_api-0.0.2/variantgrid_api/__init__.py

@@ -0,0 +1,3 @@
+from .api import *
+
+__version__ = '0.0.2'

variantgrid_api-0.0.2/variantgrid_api/add_classification.py

@@ -0,0 +1,16 @@
+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.locus:
+        classification = api.add_classifications_for_variant(args.variant, args.classification, args.public)
+
+        print("created classification: %s" % classification)
+

variantgrid_api-0.0.2/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-0.0.2/variantgrid_api/api.py

@@ -0,0 +1,125 @@
+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.0.2/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-0.0.2/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-0.0.2/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-0.0.2/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.0.2/variantgrid_api.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: variantgrid-api
+Version: 0.0.2
+Summary: API to connect to VariantGrid
+Home-page: https://bitbucket.org/sacgf/variantgrid_api
+Author: David Lawrence
+Author-email: davmlaw@gmail.com
+License: MIT License
+Description: UNKNOWN
+Platform: UNKNOWN

variantgrid_api-0.0.2/variantgrid_api.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+setup.py
+bin/vg_api
+variantgrid_api/__init__.py
+variantgrid_api/add_classification.py
+variantgrid_api/annotation.py
+variantgrid_api/api.py
+variantgrid_api/classifications.py
+variantgrid_api/gene_list.py
+variantgrid_api/variant_classification_vcf.py
+variantgrid_api/vcf_utils.py
+variantgrid_api.egg-info/PKG-INFO
+variantgrid_api.egg-info/SOURCES.txt
+variantgrid_api.egg-info/dependency_links.txt
+variantgrid_api.egg-info/not-zip-safe
+variantgrid_api.egg-info/requires.txt
+variantgrid_api.egg-info/top_level.txt

variantgrid_api-0.0.2/variantgrid_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

variantgrid_api-0.0.2/variantgrid_api.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

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

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

variantgrid_api-0.0.2/variantgrid_api.egg-info/top_level.txt

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