def test_add_tag_nullInputsProduceNullZScores(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "4"
},
"SB": {
"X": "."
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "."
},
"SB": {
"X": "8"
}
})
reader = MockVcfReader(records=[rec1, rec2])
tag = zscore_caller._ZScoreTag("ZScoreX", "ZScore for X", "X", reader)
tag.add_tag_values(rec1)
sampleA_tag_values = rec1.sample_tag_values["SA"]
self.assertEquals("-1.0", sampleA_tag_values["ZScoreX"])
sampleB_tag_values = rec1.sample_tag_values["SB"]
self.assertEquals(".", sampleB_tag_values["ZScoreX"])
def test_add_tag_zeroInputsIncluded(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "4"
},
"SB": {
"X": "0"
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "0"
},
"SB": {
"X": "8"
}
})
reader = MockVcfReader(records=[rec1, rec2])
tag = zscore_caller._ZScoreTag("ZScoreX", "ZScore for X", "X", reader)
tag.add_tag_values(rec1)
sampleA_tag_values = rec1.sample_tag_values["SA"]
self.assertEquals("0.3015", sampleA_tag_values["ZScoreX"])
sampleB_tag_values = rec1.sample_tag_values["SB"]
self.assertEquals("-0.9045", sampleB_tag_values["ZScoreX"])
def test_init_createsAllTags(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"JQ_SUMMARY_AF_RANGE": "4"
},
"SB": {
"JQ_SUMMARY_AF_RANGE": "7"
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"JQ_SUMMARY_AF_RANGE": "13"
},
"SB": {
"JQ_SUMMARY_AF_RANGE": "16"
}
})
reader = MockVcfReader(records=[rec1, rec2])
caller = zscore_caller.ZScoreCaller(reader)
self.assertEquals(2, len(caller._tags))
tag_ids = [tag.tag_id for tag in caller._tags]
self.assertIn("JQ_SUMMARY_AF_ZSCORE", tag_ids)
self.assertIn("JQ_SUMMARY_DP_ZSCORE", tag_ids)
def test_add_tag_doesNothingIfNoStdev(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "4"
},
"SB": {
"X": "4"
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "4"
},
"SB": {
"X": "4"
}
})
reader = MockVcfReader(records=[rec1, rec2])
tag = zscore_caller._ZScoreTag("ZScoreX", "ZScore for X", "X", reader)
tag.add_tag_values(rec1)
self.assertEquals(0, tag._stdev)
self.assertEqual(["X"], sorted(rec1.sample_tag_values["SA"].keys()))
self.assertEqual(["X"], sorted(rec1.sample_tag_values["SB"].keys()))
def test_add_tag(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"JQ_SUMMARY_DP_RANGE": "4"
},
"SB": {
"JQ_SUMMARY_DP_RANGE": "7"
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"JQ_SUMMARY_DP_RANGE": "13"
},
"SB": {
"JQ_SUMMARY_DP_RANGE": "16"
}
})
reader = MockVcfReader(records=[rec1, rec2])
tag = zscore_caller._DepthZScoreTag(reader)
tag.add_tag_values(rec1)
sampleA_tag_values = rec1.sample_tag_values["SA"]
self.assertEquals("-1.2649",
sampleA_tag_values["JQ_SUMMARY_DP_ZSCORE"])
sampleB_tag_values = rec1.sample_tag_values["SB"]
self.assertEquals("-0.6325",
sampleB_tag_values["JQ_SUMMARY_DP_ZSCORE"])
def test_init_setsPopulationStatistics(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "4"
},
"SB": {
"X": "7"
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "13"
},
"SB": {
"X": "16"
}
})
reader = MockVcfReader(records=[rec1, rec2])
tag = zscore_caller._ZScoreTag("ZScoreX", "ZScore for X", "X", reader)
values = [4, 7, 13, 16]
self.assertAlmostEquals(mean(values), tag._mean,
_ZScoreTag._MAX_PRECISION)
self.assertAlmostEquals(stdev(values), tag._stdev,
_ZScoreTag._MAX_PRECISION)
def test_add_tag(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "4"
},
"SB": {
"X": "7"
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "13"
},
"SB": {
"X": "16"
}
})
reader = MockVcfReader(records=[rec1, rec2])
tag = zscore_caller._ZScoreTag("ZScoreX", "ZScore for X", "X", reader)
tag.add_tag_values(rec1)
sampleA_tag_values = rec1.sample_tag_values["SA"]
self.assertEquals("-1.2649", sampleA_tag_values["ZScoreX"])
sampleB_tag_values = rec1.sample_tag_values["SB"]
self.assertEquals("-0.6325", sampleB_tag_values["ZScoreX"])
def test_vcf_records_newTagsPresent(self):
record1 = vcf.VcfRecord(chrom="chr1",
pos="21",
ref="A",
alt="G",
sample_tag_values={
"sampleA": {
"DP2": "45"
},
"sampleB": {
"DP2": "67"
}
})
record2 = vcf.VcfRecord(chrom="chr1",
pos="22",
ref="A",
alt="G",
sample_tag_values={
"sampleA": {
"TIR": "10,20",
"DP2": "100"
},
"sampleB": {
"TIR": "15,25",
"DP2": "100"
}
})
vcf_reader = MockVcfReader(records=[record1, record2])
strelka_vcf_reader = strelka._StrelkaVcfReader(vcf_reader)
vcf_records = [record for record in strelka_vcf_reader.vcf_records()]
self.assertEquals(2, len(vcf_records))
self.assertIn("DP2", vcf_records[0].format_tags)
self.assertIn(strelka.JQ_STRELKA_TAG + "DP",
vcf_records[0].format_tags)
self.assertIn(strelka.JQ_STRELKA_TAG + "HC_SOM",
vcf_records[0].format_tags)
self.assertIn(strelka.JQ_STRELKA_TAG + "CALLER_REPORTED",
vcf_records[0].format_tags)
self.assertIn(strelka.JQ_STRELKA_TAG + "CALLER_PASSED",
vcf_records[0].format_tags)
self.assertIn("TIR", vcf_records[1].format_tags)
self.assertIn(strelka.JQ_STRELKA_TAG + "AF",
vcf_records[1].format_tags)
self.assertIn(strelka.JQ_STRELKA_TAG + "HC_SOM",
vcf_records[1].format_tags)
self.assertIn(strelka.JQ_STRELKA_TAG + "CALLER_REPORTED",
vcf_records[1].format_tags)
self.assertIn(strelka.JQ_STRELKA_TAG + "CALLER_PASSED",
vcf_records[1].format_tags)
def test_vcf_records_newTagsPresent(self):
record1 = vcf.VcfRecord(chrom="chr1",
pos="21",
ref="A",
alt="G",
sample_tag_values={
"sampleA": {
"DP": "45"
},
"sampleB": {
"DP": "67"
}
})
record2 = vcf.VcfRecord(chrom="chr1",
pos="22",
ref="A",
alt="G",
sample_tag_values={
"sampleA": {
"FREQ": "46%"
},
"sampleB": {
"FREQ": "68%"
}
})
vcf_reader = MockVcfReader(records=[record1, record2])
varscan_vcf_reader = varscan._VarscanVcfReader(vcf_reader)
vcf_records = [record for record in varscan_vcf_reader.vcf_records()]
self.assertEquals(2, len(vcf_records))
self.assertIn("DP", vcf_records[0].format_tags)
self.assertIn(varscan.JQ_VARSCAN_TAG + "DP",
vcf_records[0].format_tags)
self.assertIn(varscan.JQ_VARSCAN_TAG + "HC_SOM",
vcf_records[0].format_tags)
self.assertIn(varscan.JQ_VARSCAN_TAG + "CALLER_REPORTED",
vcf_records[0].format_tags)
self.assertIn(varscan.JQ_VARSCAN_TAG + "CALLER_PASSED",
vcf_records[0].format_tags)
self.assertIn("FREQ", vcf_records[1].format_tags)
self.assertIn(varscan.JQ_VARSCAN_TAG + "AF",
vcf_records[1].format_tags)
self.assertIn(varscan.JQ_VARSCAN_TAG + "HC_SOM",
vcf_records[1].format_tags)
self.assertIn(varscan.JQ_VARSCAN_TAG + "CALLER_REPORTED",
vcf_records[1].format_tags)
self.assertIn(varscan.JQ_VARSCAN_TAG + "CALLER_PASSED",
vcf_records[1].format_tags)
def test_vcf_records_newTagsPresent(self):
record1 = vcf.VcfRecord(chrom="chr1",
pos="21",
ref="A",
alt="G",
sample_tag_values={
"sampleA": {
"DP": "45"
},
"sampleB": {
"DP": "67"
}
})
record2 = vcf.VcfRecord(chrom="chr1",
pos="22",
ref="A",
alt="G",
sample_tag_values={
"sampleA": {
"FA": "0.54"
},
"sampleB": {
"FA": "0.76"
}
})
vcf_reader = MockVcfReader(metaheaders=['##FORMAT=<ID=FA,...>'],
records=[record1, record2])
mutect_vcf_reader = mutect._MutectVcfReader(vcf_reader)
vcf_records = [record for record in mutect_vcf_reader.vcf_records()]
self.assertEquals(2, len(vcf_records))
self.assertIn("DP", vcf_records[0].format_tags)
self.assertIn(mutect.JQ_MUTECT_TAG + "DP", vcf_records[0].format_tags)
self.assertIn(mutect.JQ_MUTECT_TAG + "HC_SOM",
vcf_records[0].format_tags)
self.assertIn(mutect.JQ_MUTECT_TAG + "CALLER_REPORTED",
vcf_records[0].format_tags)
self.assertIn(mutect.JQ_MUTECT_TAG + "CALLER_PASSED",
vcf_records[0].format_tags)
self.assertIn("FA", vcf_records[1].format_tags)
self.assertIn(mutect.JQ_MUTECT_TAG + "AF", vcf_records[1].format_tags)
self.assertIn(mutect.JQ_MUTECT_TAG + "HC_SOM",
vcf_records[1].format_tags)
self.assertIn(mutect.JQ_MUTECT_TAG + "CALLER_REPORTED",
vcf_records[1].format_tags)
self.assertIn(mutect.JQ_MUTECT_TAG + "CALLER_PASSED",
vcf_records[1].format_tags)
def test_create_row_dict_fieldNamesMangledToAvoidCollision(self):
column_list = [
"CHROM", "POS", "ID", "REF", "ALT", "QUAL", "FILTER", "INFO"
] #, "FORMAT", "SAMPLE_A|NORMAL", "SAMPLE_A|TUMOR"]
# sample_tag_values = {"SAMPLE_A|NORMAL":{"DP":"50", "AF":"0.2"},
# "SAMPLE_A|TUMOR":{"DP":"87", "AF":"0.3"}}
vcf_record = vcf.VcfRecord(
"1",
"42",
"A",
"AT",
vcf_id="rs32",
qual="30",
vcf_filter="PASS",
info="SNP;REF;ALT=Yep") #sample_tag_values=sample_tag_values)
actual_dict = expand._create_row_dict(column_list, vcf_record)
expected_dict = {
"CHROM": "1",
"POS": "42",
"ID": "rs32",
"REF": "A",
"ALT": "AT",
"QUAL": "30",
"FILTER": "PASS",
"SNP": "SNP",
"INFO_REF": "REF",
"INFO_ALT": "Yep"
}
# "DP|SAMPLE_A|NORMAL": "50",
# "DP|SAMPLE_A|TUMOR": "87",
# "AF|SAMPLE_A|NORMAL": "0.2",
# "AF|SAMPLE_A|TUMOR": "0.3"}
self.assertEquals(expected_dict, actual_dict)
def _build_merged_record(coordinate, vcf_records, all_sample_names,
tags_to_keep):
all_tags = set()
sparse_matrix = {}
for record in vcf_records:
for sample, tags in record.sample_tag_values.items():
if sample not in sparse_matrix:
sparse_matrix[sample] = {}
for tag, value in list(tags.items()):
if tag in tags_to_keep:
all_tags.add(tag)
sparse_matrix[sample][tag] = value
full_matrix = OrderedDict()
for sample in all_sample_names:
full_matrix[sample] = OrderedDict()
for tag in sorted(all_tags):
try:
full_matrix[sample][tag] = sparse_matrix[sample][tag]
except KeyError:
full_matrix[sample][tag] = "."
merged_record = vcf.VcfRecord(coordinate.chrom,
coordinate.pos,
coordinate.ref,
coordinate.alt,
coordinate.vcf_id,
coordinate.qual,
coordinate.filter,
coordinate.info,
sample_tag_values=full_matrix)
return merged_record
def test_add_tag_value_validIndelAltEdgecaseNoFilter(self):
record = vcf.VcfRecord("chr1",
"42",
"A",
"ACGTNacgtn,*.",
vcf_filter="PASS")
translate._ExcludeMissingAlt().add_tag_values(record)
self.assertEquals("PASS", record.filter)
def test_add_tag_value_validIndelRefEdgecaseNoFilter(self):
record = vcf.VcfRecord("chr1",
"42",
"ACGTNacgtn",
"C",
vcf_filter="PASS")
translate._ExcludeMalformedRef().add_tag_values(record)
self.assertEquals("PASS", record.filter)
def test_add_summarize_tags(self):
file_writer = MockFileWriter()
vcf_record = vcf.VcfRecord("chr1", "42", "A", "C")
vcf_reader = MockVcfReader(records=[vcf_record])
caller = MockSummarizeCaller()
summarize._add_tags(caller, vcf_reader, file_writer)
self.assertTrue(caller.add_tags_called)
def test_add_tag_values_highConfidenceDoesNotChangeFilter(self):
record = vcf.VcfRecord("chr1", "42", "ref", "alt", vcf_filter="pass")
input_reader = MockFileReader("foo.txt", [
"chrom\tposition\tref\tvar", "chr1\t42\tref\tvar",
"chr2\t50\tref\tvar"
])
expected = "pass"
actual = _HCTag(input_reader).add_tag_values(record).filter
self.assertEquals(expected, actual)
def test_add_tag_values_lowConfidencePassingReplacesFilter(self):
record = vcf.VcfRecord("chr1", "30", "ref", "alt", vcf_filter="pass")
input_reader = MockFileReader("foo.txt", [
"chrom\tposition\tref\tvar", "chr1\t42\tref\tvar",
"chr2\t50\tref\tvar"
])
tag = _HCTag(input_reader)
expected = tag._TAG_ID
actual = tag.add_tag_values(record).filter
self.assertEquals(expected, actual)
def test_init_metaheaders(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"JQ_SUMMARY_DP_RANGE": "4"
},
"SB": {
"JQ_SUMMARY_DP_RANGE": "7"
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"JQ_SUMMARY_DP_RANGE": "13"
},
"SB": {
"JQ_SUMMARY_DP_RANGE": "16"
}
})
reader = MockVcfReader(records=[rec1, rec2])
tag = zscore_caller._DepthZScoreTag(reader)
self.assertEquals(3, len(tag.metaheaders))
it = iter(tag.metaheaders)
self.assertRegexpMatches(
next(it),
'##jacquard.summarize.JQ_SUMMARY_DP_ZSCORE.JQ_SUMMARY_DP_RANGE_mean='
)
self.assertRegexpMatches(
next(it),
'##jacquard.summarize.JQ_SUMMARY_DP_ZSCORE.JQ_SUMMARY_DP_RANGE_stdev='
)
self.assertRegexpMatches(
next(it),
'##FORMAT=<ID=JQ_SUMMARY_DP_ZSCORE,Number=1,Type=Float,Description="Concordance of reported depth.*">'
)
def test_init_metaheaders(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "4"
},
"SB": {
"X": "7"
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "13"
},
"SB": {
"X": "16"
}
})
reader = MockVcfReader(records=[rec1, rec2])
tag = zscore_caller._ZScoreTag(
"ZScoreX",
'##FORMAT=<ID=ZScoreX,Number=1,Type=Float,Description="ZScore for X">',
"X", reader)
self.assertEquals(3, len(tag.metaheaders))
it = iter(tag.metaheaders)
self.assertEquals(
next(it), '##jacquard.summarize.ZScoreX.X_mean=' + repr(tag._mean))
self.assertEquals(
next(it),
'##jacquard.summarize.ZScoreX.X_stdev=' + repr(tag._stdev))
self.assertRegexpMatches(
next(it),
'##FORMAT=<ID=ZScoreX,Number=1,Type=Float,Description="ZScore for X">'
)
def test_init_createsAllMetaheaders(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"JQ_SUMMARY_AF_RANGE": "4"
},
"SB": {
"JQ_SUMMARY_AF_RANGE": "7"
}
})
rec2 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"JQ_SUMMARY_AF_RANGE": "13"
},
"SB": {
"JQ_SUMMARY_AF_RANGE": "16"
}
})
reader = MockVcfReader(records=[rec1, rec2])
caller = zscore_caller.ZScoreCaller(reader)
self.assertEquals(6, len(caller.metaheaders))
it = iter(caller.metaheaders)
self.assertRegexpMatches(
next(it), "JQ_SUMMARY_AF_ZSCORE.JQ_SUMMARY_AF_RANGE_mean")
self.assertRegexpMatches(
next(it), "JQ_SUMMARY_AF_ZSCORE.JQ_SUMMARY_AF_RANGE_stdev")
self.assertRegexpMatches(next(it), "FORMAT=<ID=JQ_SUMMARY_AF_ZSCORE")
self.assertRegexpMatches(
next(it), "JQ_SUMMARY_DP_ZSCORE.JQ_SUMMARY_DP_RANGE_mean")
self.assertRegexpMatches(
next(it), "JQ_SUMMARY_DP_ZSCORE.JQ_SUMMARY_DP_RANGE_stdev")
self.assertRegexpMatches(next(it), "FORMAT=<ID=JQ_SUMMARY_DP_ZSCORE")
def test_vcf_records_SomHcFileSNP(self):
record1 = vcf.VcfRecord(chrom="chr1",
pos="21",
ref="A",
alt="G",
vcf_filter="PASS")
record2 = vcf.VcfRecord(chrom="chr1",
pos="22",
ref="A",
alt="T",
vcf_filter="PASS")
vcf_reader = MockVcfReader(records=[record1, record2])
content1 = ["chrom\tposition", "chr1\t21", "chr1\t22"]
somatic_hc_reader = MockFileReader("fileA.Somatic.hc.fpfilter.pass",
content1)
varscan_vcf_reader = varscan._VarscanVcfReader(vcf_reader,
somatic_hc_reader)
vcf_records = [record for record in varscan_vcf_reader.vcf_records()]
self.assertEquals(2, len(vcf_records))
self.assertIn("PASS", vcf_records[0].filter)
self.assertIn("PASS", vcf_records[1].filter)
def test_translate_files(self):
record = vcf.VcfRecord("chr1",
"42",
"A",
"C",
sample_tag_values=OrderedDict(
sorted({
"SA": OrderedDict(),
"SB": OrderedDict()
}.items())))
reader = MockVcfReader(metaheaders=["##metaheader1", "##metaheader2"],
records=[record],
sample_names=["SA", "SB"])
writer = MockWriter()
execution_context = []
new_tags = [
MockTag("TAG1",
OrderedDict(sorted({
"SA": 42,
"SB": 43
}.items())),
metaheader="##newTag1"),
MockTag("TAG2",
OrderedDict(sorted({
"SA": 420,
"SB": 430
}.items())),
metaheader="##newTag2")
]
translate._translate_files(reader, new_tags, execution_context, writer)
self.assertTrue(reader.opened)
self.assertTrue(writer.opened)
expected = [
'##metaheader1', '##metaheader2', '##newTag1', '##newTag2',
'#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tNORMAL\tTUMOR'
]
self.assertEquals(expected, writer._content[0:5])
self.assertRegexpMatches(writer._content[5], "TAG1:TAG2")
self.assertRegexpMatches(writer._content[5], "42:420")
self.assertRegexpMatches(writer._content[5], "43:430")
self.assertTrue(reader.closed)
self.assertTrue(writer.closed)
def test_create_row_dict(self):
column_list = [
"CHROM", "POS", "ID", "REF", "ALT", "QUAL", "FILTER", "INFO",
"FORMAT", "SAMPLE_A|NORMAL", "SAMPLE_A|TUMOR"
]
sample_tag_values = {
"SAMPLE_A|NORMAL": {
"DP": "50",
"AF": "0.2"
},
"SAMPLE_A|TUMOR": {
"DP": "87",
"AF": "0.3"
}
}
vcf_record = vcf.VcfRecord("1",
"42",
"A",
"AT",
vcf_id="rs32",
qual="30",
vcf_filter="PASS",
info="SNP;SOMATIC=1",
sample_tag_values=sample_tag_values)
actual_dict = expand._create_row_dict(column_list, vcf_record)
expected_dict = {
"CHROM": "1",
"POS": "42",
"ID": "rs32",
"REF": "A",
"ALT": "AT",
"QUAL": "30",
"FILTER": "PASS",
"SNP": "SNP",
"SOMATIC": "1",
"DP|SAMPLE_A|NORMAL": "50",
"DP|SAMPLE_A|TUMOR": "87",
"AF|SAMPLE_A|NORMAL": "0.2",
"AF|SAMPLE_A|TUMOR": "0.3"
}
self.assertEquals(expected_dict, actual_dict)
def test_add_tags(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "4"
},
"SB": {
"X": "7"
}
})
reader = MockVcfReader(records=[rec1])
caller = zscore_caller.ZScoreCaller(reader)
caller._tags = [MockTag("Y", {"SA": "A42", "SB": "B42"})]
caller.add_tags(rec1)
self.assertEquals({"X": "4", "Y": "A42"}, rec1.sample_tag_values["SA"])
def test_init_setsPopulationStatisticsAssignsStddevCorrectlyWhenNoValues(
self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "."
},
"SB": {
"X": "."
}
})
reader = MockVcfReader(records=[rec1])
tag = zscore_caller._ZScoreTag("ZScoreX", "ZScore for X", "X", reader)
expected_mean = None
expected_stdev = None
self.assertEquals(expected_mean, tag._mean)
self.assertEquals(expected_stdev, tag._stdev)
def test_init_setsPopulationStatisticsRoundsTo13digits(self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "1"
},
"SB": {
"X": "1"
},
"SC": {
"X": "0"
}
})
reader = MockVcfReader(records=[rec1])
tag = zscore_caller._ZScoreTag("ZScoreX", "ZScore for X", "X", reader)
self.assertEquals(round(2 / 3, 13), tag._mean, repr(tag._mean))
self.assertEquals(round(stdev([1, 1, 0]), 13), tag._stdev)
def test_init_setsPopulationStatisticsAssignsStddevCorrectlyWhenOneValue(
self):
rec1 = vcf.VcfRecord("1",
"42",
"A",
"C",
sample_tag_values={
"SA": {
"X": "4"
},
"SB": {
"X": "."
}
})
reader = MockVcfReader(records=[rec1])
tag = zscore_caller._ZScoreTag("ZScoreX", "ZScore for X", "X", reader)
values = [4]
self.assertAlmostEquals(mean(values), tag._mean,
_ZScoreTag._MAX_PRECISION)
self.assertAlmostEquals(stdev(values), tag._stdev,
_ZScoreTag._MAX_PRECISION)
def test_add_tag_value_missingAltBothReplacesFilter(self):
record = vcf.VcfRecord("chr1", "42", "A", ".*", vcf_filter="PASS")
translate._ExcludeMalformedAlt().add_tag_values(record)
self.assertEquals("JQ_EXCLUDE_MALFORMED_ALT", record.filter)
def test_add_tag_value_missingAltNullReplacesFilter(self):
record = vcf.VcfRecord("chr1", "42", "A", ".", vcf_filter="PASS")
translate._ExcludeMissingAlt().add_tag_values(record)
self.assertEquals("JQ_EXCLUDE_MISSING_ALT", record.filter)
def test_add_tag_value_missingAltBothNoFilter(self):
record = vcf.VcfRecord("chr1", "42", "A", ".*", vcf_filter="PASS")
translate._ExcludeMissingAlt().add_tag_values(record)
self.assertEquals("PASS", record.filter)
