def create_snv(self, gender, genotype):
""" create a default variant
"""
chrom = "X"
pos = "15000000"
snp_id = "."
ref = "A"
alt = "G"
qual = "50"
filt = "PASS"
# set up a SNV object, since SNV inherits VcfInfo
var = SNV(chrom, pos, snp_id, ref, alt, filt)
info = "HGNC=TEST;CQ=missense_variant;random_tag;EUR_AF=0.0005"
format_keys = "GT:DP"
sample_values = genotype + ":50"
var.vcf_line = [chrom, pos, snp_id, ref, alt, qual, filt, info, format_keys, sample_values]
var.add_info(info)
var.add_format(format_keys, sample_values)
var.set_gender(gender)
var.set_genotype()
return var
def create_snv(self, gender, genotype):
""" create a default variant
"""
chrom = "X"
pos = "15000000"
snp_id = "."
ref = "A"
alt = "G"
qual = "50"
filt = "PASS"
# set up a SNV object, since SNV inherits VcfInfo
var = SNV(chrom, pos, snp_id, ref, alt, filt)
info = "HGNC=TEST;CQ=missense_variant;random_tag;EUR_AF=0.0005"
format_keys = "GT:DP"
sample_values = genotype + ":50"
var.vcf_line = [
chrom, pos, snp_id, ref, alt, qual, filt, info, format_keys,
sample_values
]
var.add_info(info)
var.add_format(format_keys, sample_values)
var.set_gender(gender)
var.set_genotype()
return var
def create_snv(self, gender, genotype, chrom, pos, cq=None):
""" create a default variant
"""
snp_id = "."
ref = "A"
alt = "G"
filt = "PASS"
if cq is None:
cq = "missense_variant"
# set up a SNV object, since SNV inherits VcfInfo
var = SNV(chrom, pos, snp_id, ref, alt, filt)
info = "HGNC=TEST;CQ={};random_tag".format(cq)
format_keys = "GT:DP"
sample_values = genotype + ":50"
var.add_info(info)
var.add_format(format_keys, sample_values)
var.set_gender(gender)
var.set_genotype()
return var
def test_construct_variant(self):
""" test that construct_variant() works correctly
"""
# check that construct variant works for SNVs
line = ["1", "100", ".", "T", "G", "1000", "PASS", ".", "GT", "0/1"]
gender = "M"
test_var = SNV(*line[:6])
variant = self.vcf_loader.construct_variant(line, gender)
self.assertEqual(variant.get_key(), test_var.get_key())
# initally constructing a SNV shouldn't affect the format variable
self.assertEqual(variant.format, None)
# check that construct variant works for CNVs
line = [
"1", "100", ".", "T", "<DEL>", "1000", "PASS", "END=200", "GT",
"0/1"
]
gender = "M"
test_var = CNV(*line[:6])
test_var.add_info(line[7])
variant = self.vcf_loader.construct_variant(line, gender)
self.assertEqual(variant.get_key(), test_var.get_key())
self.assertNotEqual(variant.format, None)
def test_construct_variant(self):
""" test that construct_variant() works correctly
"""
# check that construct variant works for SNVs
line = ["1", "100", ".", "T", "G", "1000", "PASS", ".", "GT", "0/1"]
gender = "M"
test_var = SNV(*line[:6])
variant = construct_variant(line, gender, self.known_genes)
self.assertEqual(variant.get_key(), test_var.get_key())
# initally constructing a SNV shouldn't affect the format variable
self.assertEqual(variant.format, None)
# check that construct variant works for CNVs
line = ["1", "100", ".", "T", "<DEL>", "1000", "PASS", "END=200", "GT", "0/1"]
gender = "M"
test_var = CNV(*line[:6])
test_var.add_info(line[7])
variant = construct_variant(line, gender, self.known_genes)
self.assertEqual(variant.get_key(), test_var.get_key())
self.assertNotEqual(variant.format, None)
def test_filter_de_novos(self):
""" check that filter_de_novos() works correctly
"""
# make a family without parents
family = Family("fam_id")
child_gender = "female"
family.add_child("child_id", "child_vcf_path", "2", child_gender)
self.vcf_loader.family = family
# set up an autosomal variant
line = ["1", "100", ".", "T", "G", "1000", "PASS", ".", "GT", "0/1"]
gender = "M"
child_var = SNV(*line[:6])
child_var.add_info(line[7])
child_var.add_format(line[8], line[9])
child_var.set_gender(child_gender)
child_var.set_genotype()
# combine the variant into a list of TrioGenotypes
child_vars = [child_var]
mother_vars = []
father_vars = []
trio_variants = self.vcf_loader.combine_trio_variants(
child_vars, mother_vars, father_vars)
# check that vars without parents get passed through automatically
self.assertEqual(self.vcf_loader.filter_de_novos(trio_variants, 0.9),
trio_variants)
# now add parents to the family
family.add_mother("mother_id", "mother_vcf_path", "1", "female")
family.add_father("father_id", "father_vcf_path", "1", "male")
# re-generate the variants list now that parents have been included
trio_variants = self.vcf_loader.combine_trio_variants(
child_vars, mother_vars, father_vars)
# check that vars with parents, and that appear to be de novo are
# filtered out
self.assertEqual(self.vcf_loader.filter_de_novos(trio_variants, 0.9),
[])
# check that vars with parents, but which are not de novo, are retained
mother_vars = child_vars
trio_variants = self.vcf_loader.combine_trio_variants(
child_vars, mother_vars, father_vars)
self.assertEqual(self.vcf_loader.filter_de_novos(trio_variants, 0.9),
trio_variants)
def create_snv(self, chrom, geno="0/1"):
""" create a default variant
"""
pos = "15000000"
snp_id = "."
ref = "A"
alt = "G"
filt = "PASS"
# set up a SNV object, since SNV inherits VcfInfo
var = SNV(chrom, pos, snp_id, ref, alt, filt)
default_info = "HGNC=ATRX;CQ=missense_variant;random_tag;AF_AFR=0.0001"
keys = "GT:DP:TEAM29_FILTER:PP_DNM"
values = "{0}:50:PASS:0.99".format(geno)
var.add_info(default_info)
var.add_format(keys, values)
var.set_gender("male")
var.set_genotype()
return var
def create_snv(self, sex, genotype, cq="missense_variant", hgnc="TEST", chrom="1"):
""" create a default variant
"""
pos = "15000000"
snp_id = "."
ref = "A"
alt = "G"
filt = "PASS"
# set up a SNV object, since SNV inherits VcfInfo
var = SNV(chrom, pos, snp_id, ref, alt, filt)
info = "HGNC={0};CQ={1};DENOVO-SNP;PP_DNM=0.99".format(hgnc, cq)
keys = "GT:DP:TEAM29_FILTER:PP_DNM"
values = genotype + ":50:PASS:0.99"
var.add_info(info)
var.add_format(keys, values)
var.set_gender(sex)
var.set_genotype()
return var
def create_snv(self, gender, genotype):
""" create a default variant
"""
chrom = "1"
pos = "15000000"
snp_id = "."
ref = "A"
alt = "G"
filt = "PASS"
# set up a SNV object, since SNV inherits VcfInfo
var = SNV(chrom, pos, snp_id, ref, alt, filt)
info = "HGNC=TEST;CQ=missense_variant;DENOVO-SNP;PP_DNM=0.99"
keys = "GT:DP:TEAM29_FILTER:PP_DNM"
values = genotype + ":50:PASS:0.99"
var.add_info(info)
var.add_format(keys, values)
var.set_gender(gender)
var.set_genotype()
return var
class TestVariantInfoPy(unittest.TestCase):
"""
"""
def setUp(self):
""" define a default VcfInfo object
"""
chrom = "1"
pos = "15000000"
snp_id = "CM00001"
ref = "A"
alt = "G"
filt = "PASS"
# set up a SNV object, since SNV inherits VcfInfo
self.var = SNV(chrom, pos, snp_id, ref, alt, filt)
self.var.debug_chrom = "1"
self.var.debug_pos = "15000000"
self.default_info = "HGNC=ATRX;CQ=missense_variant;random_tag"
# here are the default filtering criteria, as loaded into python
known_genes = {"ATRX": {"inheritance": {"Hemizygous": \
{"Loss of function"}}, "start": "10000000", "chrom": "1", \
"confirmed_status": {"Confirmed DD Gene"}, "end": "20000000"}}
SNV.known_genes = known_genes
self.var.add_info(self.default_info)
def test_set_gene_from_info(self):
""" test that test_set_gene_from_info() works correctly
"""
# check for when a HGNC key exists
self.var.info["HGNC"] = "A"
self.var.set_gene_from_info()
self.assertEqual(self.var.genes, ["A"])
# check for when a HGNC key doesn't exist
del self.var.info["HGNC"]
self.var.set_gene_from_info()
self.assertIsNone(self.var.genes)
# check for multiple gene symbols
self.var.info["HGNC"] = "A|B|C"
self.var.set_gene_from_info()
self.assertEqual(self.var.genes, ["A", "B", "C"])
# check for multiple gene symbols, when some are missing
self.var.info["HGNC"] = "|.|C"
self.var.set_gene_from_info()
self.assertEqual(self.var.genes, [None, None, "C"])
# check for multiple gene symbols, when some missing symbols have
# alternates in other symbol fields.
self.var.info["HGNC"] = ".|.|C"
self.var.info["SYMBOL"] = "Z|.|C"
self.var.set_gene_from_info()
self.assertEqual(self.var.genes, ["Z", None, "C"])
# Check that including alternate symbols has the correct precendence
# order. Note that doing this properly would require checking all of the
# possible order combinations.
self.var.info["HGNC"] = ".|.|C"
self.var.info["SYMBOL"] = "Z|.|C"
self.var.info["ENSG"] = "A|.|C"
self.var.set_gene_from_info()
self.assertEqual(self.var.genes, ["Z", None, "C"])
def test_is_lof(self):
""" test that is_lof() works correctly
"""
# check that known LOF consensequence return True
self.var.consequence = ["stop_gained"]
self.assertTrue(self.var.is_lof())
# check that known non-LOF consensequence returns False
self.var.consequence = ["missense_variant"]
self.assertFalse(self.var.is_lof())
# check that null values return False
self.var.consequence = None
self.assertFalse(self.var.is_lof())
# check when the variant overlaps multiple genes (so has multiple
# gene symbols and consequences).
self.var.consequence = ["stop_gained", "missense_variant"]
self.var.genes = ["ATRX", "TTN"]
self.assertTrue(self.var.is_lof())
self.assertTrue(self.var.is_lof("ATRX"))
self.assertFalse(self.var.is_lof("TTN"))
def test_correct_multiple_alt(self):
""" test that correct_multiple_alt works correctly
"""
# define the number of alleles and consequences for multiple alleles
self.var.info["AC"] = "1,1"
cq = ["missense_variant,splice_acceptor_variant"]
# check with alts that fall in one gene
self.var.info["HGNC"] = "ATRX,ATRX"
self.var.set_gene_from_info()
self.assertEqual(self.var.correct_multiple_alt(cq),
(['splice_acceptor_variant'], ['ATRX'], None))
# check with alts that fall in multiple genes
cq = ["missense_variant|regulatory_region_variant,stop_gained|splice_acceptor_variant"]
self.var.info["HGNC"] = "ATRX|TTN,ATRX|TTN"
self.var.set_gene_from_info()
self.assertEqual(self.var.correct_multiple_alt(cq),
(['stop_gained', 'splice_acceptor_variant'], ['ATRX', 'TTN'], None))
# check a cq that has already been split by "|" (ie by gene)
cq = ["missense_variant", "regulatory_region_variant,stop_gained",
"splice_acceptor_variant"]
self.var.set_gene_from_info()
self.assertEqual(self.var.correct_multiple_alt(cq),
(['stop_gained', 'splice_acceptor_variant'], ['ATRX', 'TTN'], None))
# check that if the proband has a zero count for an allele, then we
# disregard the consequences and HGNC symbols for that allele
self.var.info["AC"] = "1,0"
self.var.set_gene_from_info()
self.assertEqual(self.var.correct_multiple_alt(cq),
(['missense_variant', 'regulatory_region_variant'], ['ATRX', 'TTN'], None))
# revert the allele counts, but drop the HGNC symbol, and make sure the
# HGNC symbol returned is None
self.var.info["AC"] = "1,1"
del self.var.info["HGNC"]
self.var.set_gene_from_info()
self.assertEqual(self.var.correct_multiple_alt(cq),
(['stop_gained', 'splice_acceptor_variant'], [], None))
def test_get_most_severe_consequence(self):
""" test that get_most_severe_consequence works correctly
"""
# check for the most simple list
cq = ["missense_variant", "splice_acceptor_variant"]
self.assertEqual(self.var.get_most_severe_consequence(cq), \
"splice_acceptor_variant")
# check for a single-entry list
cq = ["missense_variant"]
self.assertEqual(self.var.get_most_severe_consequence(cq), "missense_variant")
# check for lists of lists per allele
cq_per_allele = [["synonymous_variant", "splice_donor_variant"], \
["missense_variant", "regulatory_region_variant"]]
self.assertEqual(self.var.get_most_severe_consequence(cq_per_allele), \
["missense_variant", "splice_donor_variant"])
def test_get_per_gene_consequence(self):
""" test that get_per_gene_consequence works correctly
"""
self.var.genes = ["ATRX"]
self.var.consequence = ["missense_variant"]
self.assertEqual(self.var.get_per_gene_consequence(None), ["missense_variant"])
self.assertEqual(self.var.get_per_gene_consequence("ATRX"), ["missense_variant"])
self.assertEqual(self.var.get_per_gene_consequence("TEST"), [])
# check a variant with consequences in multiple genes, that we only
# pull out the consequencesquences for a single gene
self.var.genes = ["ATRX", "TTN"]
self.var.consequence = ["missense_variant", "synonymous_variant"]
self.assertEqual(self.var.get_per_gene_consequence("ATRX"), ["missense_variant"])
self.assertEqual(self.var.get_per_gene_consequence("TTN"), ["synonymous_variant"])
# check a symbol where two symbols match
self.var.genes = ["TEMP", "ATRX", "TEMP"]
self.var.consequence = ["splice_acceptor_variant", "missense_variant", \
"synonymous_variant"]
self.assertEqual(self.var.get_per_gene_consequence("TEMP"), \
["splice_acceptor_variant", "synonymous_variant"])
# check a symbol with some None gene symbols
self.var.genes = [None, "ATRX", None]
self.var.consequence = ["splice_acceptor_variant", "missense_variant", \
"synonymous_variant"]
self.assertEqual(self.var.get_per_gene_consequence("ATRX"), \
["missense_variant"])
# check that the earlier VCFs with single consequences but multiple
# symbols from HGNC_ALL give the same consequence for all genes.
info = "HGNC_ALL=ATRX&TTN;CQ=missense_variant;random_tag"
del self.var.info["HGNC"]
self.var.genes = None
self.var.add_info(info)
self.assertEqual(self.var.get_per_gene_consequence("ATRX"), \
["missense_variant"])
self.assertEqual(self.var.get_per_gene_consequence("TTN"), \
["missense_variant"])
def test_get_allele_frequency(self):
""" tests that number conversion works as expected
"""
# single number returns that number
self.assertEqual(self.var.get_allele_frequency("1"), 1)
# two numbers return one number
self.assertEqual(self.var.get_allele_frequency("1,1"), 1)
# two numbers return the highest number
self.assertEqual(self.var.get_allele_frequency("1,2"), 2)
# number and string return the number
self.assertEqual(self.var.get_allele_frequency("a,1"), 1)
# single string value returns None
self.assertEqual(self.var.get_allele_frequency("a"), None)
# multiple string values return None
self.assertEqual(self.var.get_allele_frequency("a,b"), None)
def test_is_number(self):
""" tests that we can check if a value represents a number
"""
self.assertEqual(self.var.is_number(None), False)
self.assertEqual(self.var.is_number("5"), True)
self.assertEqual(self.var.is_number("a"), False)
def test_find_max_allele_frequency(self):
""" test if the MAF finder operates correctly
"""
# check for var without recorded MAF
self.assertIsNone(self.var.find_max_allele_frequency())
# check for single population
self.var.info["MAX_AF"] = "0.005"
self.assertEqual(self.var.find_max_allele_frequency(), 0.005)
# check for two populations
self.var.info["AFR_AF"] = "0.01"
self.assertEqual(self.var.find_max_allele_frequency(), 0.01)
# check for all populations
pops = set(["AFR_AF", "AMR_AF", "ASN_AF", "DDD_AF", "EAS_AF", \
"ESP_AF", "EUR_AF", "MAX_AF", "SAS_AF", "UK10K_cohort_AF"])
for pop in pops:
self.var.info[pop] = "0.05"
self.assertEqual(self.var.find_max_allele_frequency(), 0.05)
class TestVariantSnvPy(unittest.TestCase):
"""
"""
def setUp(self):
""" define a default VcfInfo object
"""
chrom = "1"
pos = "15000000"
snp_id = "."
ref = "A"
alt = "G"
filt = "PASS"
# set up a SNV object, since SNV inherits VcfInfo
self.var = SNV(chrom, pos, snp_id, ref, alt, filt)
info = "HGNC=ATRX;CQ=missense_variant;random_tag"
self.pops = ["AFR_AF", "AMR_AF", "ASN_AF", "DDD_AF", \
"EAS_AF", "ESP_AF", "EUR_AF", "MAX_AF", "SAS_AF", \
"UK10K_cohort_AF"]
self.format_keys = "GT:DP"
self.sample_values = "0/1:50"
self.var.add_info(info)
def test_get_key(self):
""" tests that get_key() operates correctly
"""
# make sure the chrom and position are correct
self.var.chrom = "1"
self.var.position = "15000000"
self.assertEqual(self.var.get_key(), ("1", "15000000"))
# and make sure the chrom and position are correct if we change them
self.var.chrom = "22"
self.var.position = "123456789"
self.assertEqual(self.var.get_key(), ("22", "123456789"))
def test_convert_genotype(self):
""" test that genotypes convert from two char to single char
"""
genotypes = [("0/0", 0), ("0/1", 1), ("1/0", 1), ("1/1", 2), \
("1/2", 1), ("2/1", 1), ("0/2", 1), ("2/0", 1), ("2/2", 2)]
# run thorugh all the legit genotype codes
for geno in genotypes:
genotype = geno[0]
result = geno[1]
self.assertEqual(self.var.convert_genotype(genotype), result)
# Raise error when converting single character genotype
with self.assertRaises(ValueError):
self.var.convert_genotype("0")
# raise error when converting unknown genotype
with self.assertRaises(AssertionError):
self.var.convert_genotype("a/a")
# also include other genotype format posibilities. None of these are
# used, but since they aren't explicitly forbidden, make sure they work
# check two character strings
self.assertEqual(self.var.convert_genotype("12|34"), 1)
self.assertEqual(self.var.convert_genotype("99|99"), 2)
def test_set_default_genotype(self):
""" test that set_default_genotype() operates correctly on the autosomes
"""
self.var.set_gender("male")
self.var.set_default_genotype()
self.assertEqual(self.var.get_genotype(), 0)
def test_set_genotype_autosomal(self):
""" test that set_genotype() operates correctly
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
genotypes = [("0/0", 0), ("0/1", 1), ("1/1", 2)]
for geno in genotypes:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.get_genotype(), result)
# remove the format attribute, so we can raise an error
del self.var.format
with self.assertRaises(ValueError):
self.var.set_genotype()
def test_set_genotype_allosomal_male(self):
""" test that set_genotype() operates correctly for the male X chrom
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.chrom = "X"
self.var.set_gender("male")
genotypes = [("0/0", 0), ("1/1", 2)]
for geno in genotypes:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.get_genotype(), result)
# check that we raise an error for X chrom hets
genotypes = ["0/1", "1/0"]
for genotype in genotypes:
self.var.format["GT"] = genotype
with self.assertRaises(ValueError):
self.var.set_genotype()
def test_set_genotype_allosomal_female(self):
""" test that set_genotype() operates correctly for the female X chrom
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.chrom = "X"
self.var.set_gender("female")
genotypes = [("0/0", 0), ("0/1", 1), ("1/1", 2)]
for geno in genotypes:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.get_genotype(), result)
def test_is_het_autosomal(self):
""" tests that is_het() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
het = [("0/0", False), ("0/1", True), ("1/1", False)]
for geno in het:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_het(), result)
def test_is_hom_alt_autosomal(self):
""" tests that is_hom_alt() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
hom_alt = [("0/0", False), ("0/1", False), ("1/1", True)]
for geno in hom_alt:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_hom_alt(), result)
def test_is_hom_ref_autosomal(self):
""" tests that is_hom_ref() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
hom_ref = [("0/0", True), ("0/1", False), ("1/1", False)]
for geno in hom_ref:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_hom_ref(), result)
def test_is_not_ref_autosomal(self):
""" tests that is_not_ref() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
not_ref = [("0/0", False), ("0/1", True), ("1/1", True)]
for geno in not_ref:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_not_ref(), result)
def test_is_not_alt_autosomal(self):
""" tests that is_not_ref() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
not_alt = [("0/0", True), ("0/1", True), ("1/1", False)]
for geno in not_alt:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_not_alt(), result)
def test_passes_default_filters(self):
""" test that different variants pass or fail the VcfInfo filters
"""
# check that a default variant passes the filters
self.assertTrue(self.var.passes_filters())
def test_passes_alternate_filter_string(self):
""" test that the alternate permitted FILTER string also passes
"""
# check that the alternate FILTER value passes
self.var.filter = "."
self.assertTrue(self.var.passes_filters())
self.var.filter = "FAIL"
self.assertFalse(self.var.passes_filters())
# check that low VQSLOD on its own will pass the variant
self.var.filter = "LOW_VQSLOD"
self.assertTrue(self.var.passes_filters())
# check that low VQSLOD in a de novo will still pass
self.var.filter = "LOW_VQSLOD"
self.var.info["DENOVO-SNP"] = True
self.assertTrue(self.var.passes_filters())
def test_passes_filters_low_maf(self):
""" tests that low MAF values pass the filters
"""
# check that low MAF values pass the filters
for pop in self.pops:
self.var.info[pop] = "0.005"
self.assertTrue(self.var.passes_filters())
# and check that MAF on the threshold still pass
self.var.info[pop] = "0.01"
self.assertTrue(self.var.passes_filters())
def test_out_of_range_maf(self):
""" check that MAF outside 0-1 still pass or fail correctly
"""
self.var.info["AFR_AF"] = "-1"
self.assertTrue(self.var.passes_filters())
self.var.info["AFR_AF"] = "100"
self.assertFalse(self.var.passes_filters())
def test_fails_filters_high_maf(self):
""" test that variants with high MAF fail the filtering
"""
# check th
for pop in self.pops:
var = self.var
var.info[pop] = "0.0101"
self.assertFalse(var.passes_filters())
def test_passes_consequence_filter(self):
""" check all the consequence values that should pass
"""
vep_passing = ["transcript_ablation", "splice_donor_variant", \
"splice_acceptor_variant", "frameshift_variant", \
"initiator_codon_variant", "inframe_insertion", "inframe_deletion",\
"missense_variant", "transcript_amplification", "stop_gained",\
"stop_lost", "coding_sequence_variant"]
# check all the passing consequences
for cq in vep_passing:
self.var.consequence = [cq]
self.assertTrue(self.var.passes_filters())
def test_fails_consequence_filter(self):
""" check all the consequence values that should fail
"""
vep_failing = ["splice_region_variant", \
"incomplete_terminal_codon_variant", "synonymous_variant", \
"stop_retained_variant", "mature_miRNA_variant", \
"5_prime_UTR_variant", "3_prime_UTR_variant", \
"non_coding_exon_variant", "nc_transcript_variant", \
"intron_variant", "NMD_transcript_variant", \
"upstream_gene_variant", "downstream_gene_variant", \
"TFBS_ablation", "TFBS_amplification", "TF_binding_site_variant", \
"regulatory_region_variant", "regulatory_region_ablation", \
"regulatory_region_amplification", "feature_elongation", \
"feature_truncation", "intergenic_variant"]
# check all the failing consequences
for cq in vep_failing:
self.var.consequence = [cq]
self.assertFalse(self.var.passes_filters())
def test_passes_filters_with_debug(self):
""" check that passes_filters_with_debug() generates a failure message
"""
# make a variant that will fail the filtering, and set the site for
# debugging
self.var.info["AFR_AF"] = "0.05"
self.var.debug_pos = self.var.get_position()
# get ready to capture the output from a print function
out = StringIO()
sys.stdout = out
# check that the variant fails (and secondarily prints the failure mode)
self.assertFalse(self.var.passes_filters_with_debug())
output = out.getvalue().strip()
# check that the message about why the variant failed filtering is correct
self.assertEqual(output, "failed MAF: 0.05")
class TestVariantSnvPy(unittest.TestCase):
"""
"""
def setUp(self):
""" define a default VcfInfo object
"""
chrom = "1"
pos = "15000000"
snp_id = "."
ref = "A"
alt = "G"
filt = "PASS"
# set up a SNV object, since SNV inherits VcfInfo
self.var = SNV(chrom, pos, snp_id, ref, alt, filt)
info = "HGNC=ATRX;CQ=missense_variant;random_tag"
self.pops = ["AFR_AF", "AMR_AF", "ASN_AF", "DDD_AF", \
"EAS_AF", "ESP_AF", "EUR_AF", "MAX_AF", "SAS_AF", \
"UK10K_cohort_AF"]
self.format_keys = "GT:DP"
self.sample_values = "0/1:50"
self.var.add_info(info)
def test_get_key(self):
""" tests that get_key() operates correctly
"""
# make sure the chrom and position are correct
self.var.chrom = "1"
self.var.position = "15000000"
self.assertEqual(self.var.get_key(), ("1", "15000000"))
# and make sure the chrom and position are correct if we change them
self.var.chrom = "22"
self.var.position = "123456789"
self.assertEqual(self.var.get_key(), ("22", "123456789"))
def test_convert_genotype(self):
""" test that genotypes convert from two char to single char
"""
genotypes = [("0/0", 0), ("0/1", 1), ("1/0", 1), ("1/1", 2), \
("1/2", 1), ("2/1", 1), ("0/2", 1), ("2/0", 1), ("2/2", 2)]
# run thorugh all the legit genotype codes
for geno in genotypes:
genotype = geno[0]
result = geno[1]
self.assertEqual(self.var.convert_genotype(genotype), result)
# Raise error when converting single character genotype
with self.assertRaises(ValueError):
self.var.convert_genotype("0")
# raise error when converting unknown genotype
with self.assertRaises(AssertionError):
self.var.convert_genotype("a/a")
# also include other genotype format posibilities. None of these are
# used, but since they aren't explicitly forbidden, make sure they work
# check two character strings
self.assertEqual(self.var.convert_genotype("12|34"), 1)
self.assertEqual(self.var.convert_genotype("99|99"), 2)
def test_set_default_genotype(self):
""" test that set_default_genotype() operates correctly on the autosomes
"""
self.var.set_gender("male")
self.var.set_default_genotype()
self.assertEqual(self.var.get_genotype(), 0)
def test_set_genotype_autosomal(self):
""" test that set_genotype() operates correctly
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
genotypes = [("0/0", 0), ("0/1", 1), ("1/1", 2)]
for geno in genotypes:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.get_genotype(), result)
# remove the format attribute, so we can raise an error
del self.var.format
with self.assertRaises(ValueError):
self.var.set_genotype()
def test_set_genotype_allosomal_male(self):
""" test that set_genotype() operates correctly for the male X chrom
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.chrom = "X"
self.var.set_gender("male")
genotypes = [("0/0", 0), ("1/1", 2)]
for geno in genotypes:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.get_genotype(), result)
# check that we raise an error for X chrom hets
genotypes = ["0/1", "1/0"]
for genotype in genotypes:
self.var.format["GT"] = genotype
with self.assertRaises(ValueError):
self.var.set_genotype()
def test_set_genotype_allosomal_female(self):
""" test that set_genotype() operates correctly for the female X chrom
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.chrom = "X"
self.var.set_gender("female")
genotypes = [("0/0", 0), ("0/1", 1), ("1/1", 2)]
for geno in genotypes:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.get_genotype(), result)
def test_is_het_autosomal(self):
""" tests that is_het() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
het = [("0/0", False), ("0/1", True), ("1/1", False)]
for geno in het:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_het(), result)
def test_is_hom_alt_autosomal(self):
""" tests that is_hom_alt() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
hom_alt = [("0/0", False), ("0/1", False), ("1/1", True)]
for geno in hom_alt:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_hom_alt(), result)
def test_is_hom_ref_autosomal(self):
""" tests that is_hom_ref() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
hom_ref = [("0/0", True), ("0/1", False), ("1/1", False)]
for geno in hom_ref:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_hom_ref(), result)
def test_is_not_ref_autosomal(self):
""" tests that is_not_ref() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
not_ref = [("0/0", False), ("0/1", True), ("1/1", True)]
for geno in not_ref:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_not_ref(), result)
def test_is_not_alt_autosomal(self):
""" tests that is_not_ref() operates correctly for automsal chromosomes
"""
self.var.add_format(self.format_keys, self.sample_values)
self.var.set_gender("male")
not_alt = [("0/0", True), ("0/1", True), ("1/1", False)]
for geno in not_alt:
genotype = geno[0]
result = geno[1]
self.var.format["GT"] = genotype
self.var.set_genotype()
self.assertEqual(self.var.is_not_alt(), result)
def test_passes_default_filters(self):
""" test that different variants pass or fail the VcfInfo filters
"""
# check that a default variant passes the filters
self.assertTrue(self.var.passes_filters())
def test_passes_alternate_filter_string(self):
""" test that the alternate permitted FILTER string also passes
"""
# check that the alternate FILTER value passes
self.var.filter = "."
self.assertTrue(self.var.passes_filters())
self.var.filter = "FAIL"
self.assertFalse(self.var.passes_filters())
# check that low VQSLOD on its own will pass the variant
self.var.filter = "LOW_VQSLOD"
self.assertTrue(self.var.passes_filters())
# check that low VQSLOD in a de novo will still pass
self.var.filter = "LOW_VQSLOD"
self.var.info["DENOVO-SNP"] = True
self.assertTrue(self.var.passes_filters())
def test_passes_filters_low_maf(self):
""" tests that low MAF values pass the filters
"""
# check that low MAF values pass the filters
for pop in self.pops:
self.var.info[pop] = "0.005"
self.assertTrue(self.var.passes_filters())
# and check that MAF on the threshold still pass
self.var.info[pop] = "0.01"
self.assertTrue(self.var.passes_filters())
def test_out_of_range_maf(self):
""" check that MAF outside 0-1 still pass or fail correctly
"""
self.var.info["AFR_AF"] = "-1"
self.assertTrue(self.var.passes_filters())
self.var.info["AFR_AF"] = "100"
self.assertFalse(self.var.passes_filters())
def test_fails_filters_high_maf(self):
""" test that variants with high MAF fail the filtering
"""
# check th
for pop in self.pops:
var = self.var
var.info[pop] = "0.0101"
self.assertFalse(var.passes_filters())
def test_passes_consequence_filter(self):
""" check all the consequence values that should pass
"""
vep_passing = ["transcript_ablation", "splice_donor_variant", \
"splice_acceptor_variant", "frameshift_variant", \
"initiator_codon_variant", "inframe_insertion", "inframe_deletion",\
"missense_variant", "transcript_amplification", "stop_gained",\
"stop_lost", "coding_sequence_variant"]
# check all the passing consequences
for cq in vep_passing:
self.var.consequence = [cq]
self.assertTrue(self.var.passes_filters())
def test_fails_consequence_filter(self):
""" check all the consequence values that should fail
"""
vep_failing = ["splice_region_variant", \
"incomplete_terminal_codon_variant", "synonymous_variant", \
"stop_retained_variant", "mature_miRNA_variant", \
"5_prime_UTR_variant", "3_prime_UTR_variant", \
"non_coding_exon_variant", "nc_transcript_variant", \
"intron_variant", "NMD_transcript_variant", \
"upstream_gene_variant", "downstream_gene_variant", \
"TFBS_ablation", "TFBS_amplification", "TF_binding_site_variant", \
"regulatory_region_variant", "regulatory_region_ablation", \
"regulatory_region_amplification", "feature_elongation", \
"feature_truncation", "intergenic_variant"]
# check all the failing consequences
for cq in vep_failing:
self.var.consequence = [cq]
self.assertFalse(self.var.passes_filters())
def test_passes_filters_with_debug(self):
""" check that passes_filters_with_debug() generates a failure message
"""
# make a variant that will fail the filtering, and set the site for
# debugging
self.var.info["AFR_AF"] = "0.05"
self.var.debug_pos = self.var.get_position()
# get ready to capture the output from a print function
out = StringIO()
sys.stdout = out
# check that the variant fails (and secondarily prints the failure mode)
self.assertFalse(self.var.passes_filters_with_debug())
output = out.getvalue().strip()
# check that the message about why the variant failed filtering is correct
self.assertEqual(output, "failed MAF: 0.05")
class TestVariantInfoPy(unittest.TestCase):
"""
"""
def setUp(self):
""" define a default VcfInfo object
"""
chrom = "1"
pos = "15000000"
snp_id = "CM00001"
ref = "A"
alt = "G"
filt = "PASS"
# set up a SNV object, since SNV inherits VcfInfo
self.var = SNV(chrom, pos, snp_id, ref, alt, filt)
self.var.debug_chrom = "1"
self.var.debug_pos = "15000000"
self.default_info = "HGNC=ATRX;CQ=missense_variant;random_tag"
# here are the default filtering criteria, as loaded into python
known_genes = {"ATRX": {"inheritance": {"Hemizygous": \
{"Loss of function"}}, "start": "10000000", "chrom": "1", \
"confirmed_status": {"Confirmed DD Gene"}, "end": "20000000"}}
SNV.known_genes = known_genes
self.var.add_info(self.default_info)
def test_set_gene_from_info(self):
""" test that test_set_gene_from_info() works correctly
"""
# check for when a HGNC key exists
self.var.info["HGNC"] = "A"
self.var.set_gene_from_info()
self.assertEqual(self.var.gene, "A")
# check for when a HGNC key doesn't exist
del self.var.info["HGNC"]
self.var.set_gene_from_info()
self.assertIsNone(self.var.gene)
def test_is_lof(self):
""" test that is_lof() works correctly
"""
# check that known LOF consensequence return True
self.var.consequence = "stop_gained"
self.assertTrue(self.var.is_lof())
# check that known non-LOF consensequence returns False
self.var.consequence = "missense_variant"
self.assertFalse(self.var.is_lof())
# check that null values return False
self.var.consequence = None
self.assertFalse(self.var.is_lof())
def test_get_allele_frequency(self):
""" tests that number conversion works as expected
"""
# single number returns that number
self.assertEqual(self.var.get_allele_frequency("1"), 1)
# two numbers return one number
self.assertEqual(self.var.get_allele_frequency("1,1"), 1)
# two numbers return the highest number
self.assertEqual(self.var.get_allele_frequency("1,2"), 2)
# number and string return the number
self.assertEqual(self.var.get_allele_frequency("a,1"), 1)
# single string value returns None
self.assertEqual(self.var.get_allele_frequency("a"), None)
# multiple string values return None
self.assertEqual(self.var.get_allele_frequency("a,b"), None)
def test_is_number(self):
""" tests that we can check if a value represents a number
"""
self.assertEqual(self.var.is_number(None), False)
self.assertEqual(self.var.is_number("5"), True)
self.assertEqual(self.var.is_number("a"), False)
def test_find_max_allele_frequency(self):
""" test if the MAF finder operates correctly
"""
# check for var without recorded MAF
self.assertIsNone(self.var.find_max_allele_frequency())
# check for single population
self.var.info["MAX_AF"] = "0.005"
self.assertEqual(self.var.find_max_allele_frequency(), 0.005)
# check for two populations
self.var.info["AFR_AF"] = "0.01"
self.assertEqual(self.var.find_max_allele_frequency(), 0.01)
# check for all populations
pops = set(["AFR_AF", "AMR_AF", "ASN_AF", "DDD_AF", "EAS_AF", \
"ESP_AF", "EUR_AF", "MAX_AF", "SAS_AF", "UK10K_cohort_AF"])
for pop in pops:
self.var.info[pop] = "0.05"
self.assertEqual(self.var.find_max_allele_frequency(), 0.05)
