def test_transform_variant(self):
     variant = GeneVariant(expr='NC_000001.10:g.11856378G>A')
     assert variant.transform_variant(
         GeneVariant.TRANSFORM_CHR_POS_REF_ALT) == [
             '1', '11856378', 'G', 'A'
         ]
     assert variant.transform_variant(
         GeneVariant.TRANSFORM_CHR_POS) == ['1', '11856378']
 def test_get_variant_url(self):
     variant = GeneVariant('chr1:g.11856378G>A')
     assert GnomAD.get_variant_url(
         variant) == GnomAD.VARIANT_ROUTE + '1-11856378-G-A'
     variant = GeneVariant('NM_001098210.1:c.241+6_241+7del')
     assert GnomAD.get_variant_url(
         variant) == GnomAD.VARIANT_ROUTE + '3-41266247-AAG-A'
     variant = GeneVariant('NC_000003.11:g.41266248_41266249delAG')
     assert GnomAD.get_variant_url(
         variant) == GnomAD.VARIANT_ROUTE + '3-41266247-AAG-A'
 def test_type(self):
     variant = GeneVariant(expr='NM_005957.4:c.665C>T')
     assert variant.ref_type == GeneVariant.REF_TYPE_NM
     variant = GeneVariant(expr='ENST_005957.4:c.665C>T')
     assert variant.ref_type == GeneVariant.REF_TYPE_ENST
     variant = GeneVariant(expr='NC_005957.4:c.665C>T')
     assert variant.ref_type == GeneVariant.REF_TYPE_NC
     variant = GeneVariant(expr='NP_005957.4:c.665C>T')
     assert variant.ref_type == GeneVariant.REF_TYPE_NP
     variant = GeneVariant(expr='chr1:g.11856378G>A')
     assert variant.ref_type == GeneVariant.REF_TYPE_CHR
    def test_search_variants(self):
        variant = GeneVariant("chr1:g.114716127G>A")
        assert COSMIC.search_variant_db(variant=variant, only_count=True) > 0

        # cDNA
        variant = GeneVariant("ENST00000376236:c.1089C>T")
        assert COSMIC.search_variant_db(variant=variant, only_count=True) > 0

        variant = GeneVariant("ENST00000376236:p.N363N")
        assert COSMIC.search_variant_db(variant=variant, only_count=True) > 0

        variant = GeneVariant("ENST00000376236:p.Asn363Asn")
        assert COSMIC.search_variant_db(variant=variant, only_count=True) > 0
 def test_init(self):
     with pytest.raises(ValueError) as excinfo:
         GeneVariant()
     with pytest.raises(ValueError) as excinfo:
         GeneVariant(ref_seq='NM_005957.4')
     with pytest.raises(ValueError) as excinfo:
         GeneVariant(var_info='c.665C>T')
     with pytest.raises(ValueError) as excinfo:
         GeneVariant(expr='ABC_1234')
     with pytest.raises(ValueError) as excinfo:
         GeneVariant(ref_seq='ABC_1234', var_info='c.665C>T')
     GeneVariant(ref_seq='NM_005957.4', var_info='c.665C>T')
     GeneVariant(expr='NM_005957.4:c.665C>T')
    def test_transform_ref_seq_else(self):
        variant = GeneVariant(expr='chr1:g.11856378G>A')
        assert variant.transform_ref_seq(GeneVariant.REF_TYPE_NM)
        variant = GeneVariant(expr='chr1:g.11856378G>A')
        assert variant.transform_ref_seq(GeneVariant.REF_TYPE_NP)
        variant = GeneVariant(expr='chr1:g.11856378G>A')
        assert variant.transform_ref_seq(GeneVariant.REF_TYPE_NC)

        variant = GeneVariant(expr='NM_005957.4:c.665C>T')
        assert variant.transform_ref_seq(GeneVariant.REF_TYPE_CHR)
        variant = GeneVariant(expr='NP_005948.3:p.Ala222Val')
        assert variant.transform_ref_seq(GeneVariant.REF_TYPE_CHR)
        variant = GeneVariant(expr='NC_000001.10:g.11856378G>A')
        assert variant.transform_ref_seq(GeneVariant.REF_TYPE_CHR)
    def test_transform_ref_seq_ENST(self):
        variant = GeneVariant(expr='NM_005957.4:c.665C>T')
        assert variant.transform_ref_seq(GeneVariant.REF_TYPE_ENST)

        variant = GeneVariant(expr='ENST00000376590:c.665C>T')
        assert variant.transform_ref_seq(GeneVariant.REF_TYPE_NM)
 def test_search_variant_local(self):
     variant = GeneVariant('PTEN:c.697C>T')
     res = MyCancerGenome.search_variant_local(variant)
     assert res and res['variant_match'] == True and res[
         'url'] == 'https://www.mycancergenome.org/content/gene/PTEN'
 def test_search_variant(self):
     variant = GeneVariant('chr1:g.11856378G>A')
     assert DECIPHER.get_variant_url(
         variant
     ) == 'https://decipher.sanger.ac.uk/search?q=1%3A11856378#consented-patients/results'
 def test_search_variant(self):
     variant = GeneVariant('chr1:g.11856378G>A')
     assert GTEx.get_variant_url(
         variant) == GTEx.VARIANT_ROUTE + 'rs1801133'
 def test_search_variant(self):
     variant = GeneVariant('chr1:g.11856378G>A')
     assert CIViC.search_variant(variant)
 def test_search_variant(self):
     variant = GeneVariant('chr7:g.140453134T>C')
     res = GDC.search_variant(variant)
     assert res and res[
         'url'] == 'https://portal.gdc.cancer.gov/ssms/3d2daeb9-3ede-594a-8a84-c84e7fd453df'
Example #13
0
def search_sources(target_str, search_type):
    redis_key = None
    if search_type == TYPE_GENE or search_type == TYPE_TRANSCRIPT:
        target = GeneReference(target_str)
        redis_gene_name = target.transform_ref_seq(GeneReference.REF_TYPE_GENE)
        if redis_gene_name:
            redis_key = redis_gene_name
    elif search_type == TYPE_VARIANT:
        target = GeneVariant(target_str)
        redis_gene_name = target.transform_ref_seq(GeneReference.REF_TYPE_GENE)
        c_info = target.transform_variant(target.ref_type,
                                          GeneVariant.INFO_TYPE_C)[1]
        if redis_gene_name and c_info:
            redis_key = redis_gene_name + ':' + c_info
    else:
        raise ValueError("Invalid search type")
    if redis_key:
        search_result = REDIS_SEARCH.get(redis_key)
        if search_result:
            print 'READ FROM REDIS CACHE'
            return json.loads(search_result)

    mv_res = target.get_myvariant_res()
    res = {MY_VARIANT: mv_res, SOURCE_NAMES_KEY: {}}

    for source in GENE_SOURCES:
        time_start = time.clock()
        if search_type == TYPE_GENE:
            source_res = source.search_gene(target)
        elif search_type == TYPE_VARIANT:
            source_res = source.search_variant(target)
        elif search_type == TYPE_TRANSCRIPT:
            source_res = source.search_transcript(target)

        if search_type == TYPE_VARIANT and not source_res:
            source_res = source.search_transcript(target)
            if source_res:
                source_res['downgrade'] = 'Transcript'

        if search_type != TYPE_GENE and not source_res:
            source_res = source.search_gene(target)
            if source_res:
                source_res['downgrade'] = 'Gene'
        res[source.__name__.lower()] = source_res
        res[SOURCE_NAMES_KEY][source.__name__.lower()] = source.__name__
        time_elapsed = (time.clock() - time_start)
        print source.__name__ + ' takes time ' + str(time_elapsed)
    prepare_source_report(res, search_type)
    report = res[REPORT_KEY]

    time_start = time.clock()
    all_ids = target.get_all_ids()
    time_elapsed = (time.clock() - time_start)
    print 'All ids takes time ' + str(time_elapsed)
    report[IDS_KEY] = all_ids

    if search_type == TYPE_VARIANT:
        aa = target.get_aa()
        print aa
        if aa[0] and aa[1]:
            # calculate grantham score
            def translate_grantham_score(score):
                if score > 150:
                    return unicode(_("Radical Substitution"))
                elif score <= 150 and score > 100:
                    return unicode(_("Moderately Radical Substitution"))
                elif score <= 100 and score > 50:
                    return unicode(_("Moderately Conservative Substitution"))
                elif score <= 50 and score >= 0:
                    return unicode(_("Conservative Substitution"))
                return 'N/A'

            grantham_score = GeneVariant.calculate_grantham_score(ref_aa=aa[0],
                                                                  alt_aa=aa[1])
            report[GRANTHAM_SCORE_KEY] = grantham_score
            report[GRANTHAM_INFO_KEY] = translate_grantham_score(
                grantham_score)
            # add in aa info
            report[REF_AA_KEY] = aa[0]
            report[ALT_AA_KEY] = aa[1]

    # save to redis
    if redis_key:
        REDIS_SEARCH.set(redis_key, json.dumps(res),
                         ex=2073600)  # TODO: Current: 1day
    return res