/** * Creates a {@code Stream} of {@code VariantContext} from the indicated VCF file. * * @param vcfPath path of the VCF file * @return a {@code Stream} of {@code VariantContext} */ public static Stream<VariantContext> readVariantContexts(Path vcfPath) { Objects.requireNonNull(vcfPath, "Cannot read from null vcfPath"); logger.info("Reading variants from VCF file {}", vcfPath); try (VCFFileReader vcfReader = new VCFFileReader(vcfPath, false)) { return vcfReader.iterator().stream(); } }
public <T> VcfIterator<T> iterator(VariantFilters<VariantContext> filters, Class<T> clazz) { open(); CloseableIterator<VariantContext> variantContextIterator = vcfReader.iterator(); return getVariantIterator(filters, clazz, variantContextIterator); }
private CloseableIterator<IdsvVariantContext> getVcf() { VCFFileReader vcfReader = new VCFFileReader(vcf, false); CloseableIterator<VariantContext> it = vcfReader.iterator(); Iterator<IdsvVariantContext> idsvIt = Iterators.transform(it, variant -> IdsvVariantContext.create(context, null, variant)); return new AutoClosingIterator<IdsvVariantContext>(idsvIt, it, vcfReader); } private ExternalProcessStreamingAligner createRecordAlignmentStream() {
@Test(dataProvider = "filteringIteratorData") public void testFilteringIterator(final VariantContextFilter filter, final int expectedCount) { final File vcf = new File(testDir,"ex2.vcf"); final VCFFileReader vcfReader = new VCFFileReader(vcf, false); final FilteringVariantContextIterator filteringIterator = new FilteringVariantContextIterator(vcfReader.iterator(), filter); int count = 0; for(final VariantContext vc : filteringIterator) { count++; } Assert.assertEquals(count, expectedCount); }
@Test(dataProvider = "vcfshards") public void TestGatherFiles(final List<File> inputFiles, final File expectedOutput, final int expectedRetVal) throws IOException { final List<String> args = new ArrayList<>(); final File output = VcfTestUtils.createTemporaryIndexedFile("result", expectedOutput.getAbsolutePath().endsWith(".vcf") ? ".vcf" : ".vcf.gz"); inputFiles.forEach(f -> args.add("INPUT=" + f.getAbsolutePath())); args.add("OUTPUT=" + output.getAbsolutePath()); Assert.assertEquals(runPicardCommandLine(args.toArray(new String[args.size()])), expectedRetVal, "Program was expected to run successfully, but didn't."); if (expectedRetVal == 0) { final VCFFileReader expectedReader = new VCFFileReader(expectedOutput, false); final VCFFileReader outputReader = new VCFFileReader(output, false); Assert.assertEquals(expectedReader.iterator().stream().count(), outputReader.iterator().stream().count(), "The wrong number of variants was found."); } } }
private static List<IdsvVariantContext> loadTruthVcf(GenomicProcessingContext processContext, File truthVcf) { List<IdsvVariantContext> truth = Lists.newArrayList(); VCFFileReader vcfReader = null; CloseableIterator<VariantContext> it = null; try { vcfReader = new VCFFileReader(truthVcf, false); it = vcfReader.iterator(); while (it.hasNext()) { truth.add(IdsvVariantContext.create(processContext, null, it.next())); } } finally { CloserUtil.close(it); CloserUtil.close(vcfReader); } return truth; } public VariantContextDirectedEvidence annotate(VariantContextDirectedEvidence variant) {
@Test public void shouldPreserveSymbolicAlleleCase() { final VariantContext variant; try (final VCFFileReader reader = new VCFFileReader(new File(VariantBaseTest.variantTestDataRoot + "breakpoint.vcf"), false)) { variant = reader.iterator().next(); } // VCF v4.1 s1.4.5 // Tools processing VCF files are not required to preserve case in the allele String, except for IDs, which are case sensitive. Assert.assertTrue(variant.getAlternateAllele(0).getDisplayString().contains("chr12")); }
@Test(dataProvider = "liftoverReverseStrand") public void testReverseComplementedIndels(final String filename, final int expectedPassing, final int expectedFailing) { final File liftOutputFile = new File(OUTPUT_DATA_PATH, "lift-delete-me.vcf"); final File rejectOutputFile = new File(OUTPUT_DATA_PATH, "reject-delete-me.vcf"); final File input = new File(TEST_DATA_PATH, filename); liftOutputFile.deleteOnExit(); rejectOutputFile.deleteOnExit(); final String[] args = new String[]{ "INPUT=" + input.getAbsolutePath(), "OUTPUT=" + liftOutputFile.getAbsolutePath(), "REJECT=" + rejectOutputFile.getAbsolutePath(), "CHAIN=" + CHAIN_FILE, "REFERENCE_SEQUENCE=" + REFERENCE_FILE, "RECOVER_SWAPPED_REF_ALT=true", "CREATE_INDEX=false" }; Assert.assertEquals(runPicardCommandLine(args), 0); final VCFFileReader liftReader = new VCFFileReader(liftOutputFile, false); Assert.assertEquals(liftReader.iterator().stream().count(), expectedPassing, "The wrong number of variants were lifted over."); final VCFFileReader rejectReader = new VCFFileReader(rejectOutputFile, false); Assert.assertEquals(rejectReader.iterator().stream().count(), expectedFailing, "The wrong number of variants were rejected."); }
@Test public void testGLnotOverridePL() { final VariantContext variant; try (final VCFFileReader reader = new VCFFileReader( new File("src/test/resources/htsjdk/variant/test_withGLandPL.vcf"), false)) { variant = reader.iterator().next(); } Assert.assertEquals(variant.getGenotype(0).getPL(), new int[]{45, 0, 50}); } }
private IntervalCoverageAccumulator initIntervalCoverageAccumulator() { SAMSequenceDictionary dictionary = getReference().getSequenceDictionary(); if (VCF == null) { return new IntervalCoverageAccumulator(COVERAGE_METHOD, dictionary, BIN_SIZE, null); } else { try (VCFFileReader vcfReader = new VCFFileReader(VCF, false)) { try (CloseableIterator<VariantContext> it = vcfReader.iterator()) { GenomicProcessingContext pc = new GenomicProcessingContext(new FileSystemContext(TMP_DIR.get(0), MAX_RECORDS_IN_RAM), REFERENCE_SEQUENCE, getReference()); Iterator<IdsvVariantContext> idsvIt = Iterators.transform(it, variant -> IdsvVariantContext.create(pc, null, variant)); Iterator<VariantContextDirectedEvidence> bpit = Iterators.filter(idsvIt, VariantContextDirectedEvidence.class); return new IntervalCoverageAccumulator(COVERAGE_METHOD, dictionary, BIN_SIZE, bpit); } } } } @Override
public CloseableIterator<VariantContextDirectedEvidence> getBreakends(File file) { VCFFileReader vcfReader = new VCFFileReader(file, false); CloseableIterator<VariantContext> it = vcfReader.iterator(); Iterator<IdsvVariantContext> idsvIt = Iterators.transform(it, variant -> IdsvVariantContext.create(getContext(), null, variant)); Iterator<VariantContextDirectedEvidence> beit = Iterators.filter(idsvIt, VariantContextDirectedEvidence.class); // resort by evidence start beit = new DirectEvidenceWindowedSortingIterator<>(getContext(), SAMEvidenceSource.maximumWindowSize(getContext(), getSamEvidenceSources(), getAssemblySource()), beit); return new AutoClosingIterator<VariantContextDirectedEvidence>(beit, it, vcfReader); } public Iterator<IdsvVariantContext> getAllCalls(File file, CloseableIterator<VariantContextDirectedEvidence> breakendCalls) {
@Test(dataProvider = "badSampleData", expectedExceptions = IllegalArgumentException.class) public void testMissingSample(final String file, final String sample) { final File vcf = new File(testDir, file); final VCFFileReader vcfReader = new VCFFileReader(vcf, false); final HeterozygosityFilter heterozygosityFilter = new HeterozygosityFilter(true, sample); new FilteringVariantContextIterator(vcfReader.iterator(), heterozygosityFilter).next(); } }
public Iterator<IdsvVariantContext> getAllCalls(File file, CloseableIterator<VariantContextDirectedEvidence> breakendCalls) { VCFFileReader vcfReader = new VCFFileReader(file, false); if (inputHeader != null) { inputHeader = vcfReader.getFileHeader(); } CloseableIterator<VariantContext> it = vcfReader.iterator(); Iterator<IdsvVariantContext> idsvIt = Iterators.transform(it, variant -> IdsvVariantContext.create(getContext(), null, variant)); Iterator<IdsvVariantContext> nonbeIt = Iterators.filter(idsvIt, variant -> !(variant instanceof VariantContextDirectedEvidence)); // sort back to nominal VCF position Iterator<VariantContextDirectedEvidence> bpit = new VariantContextWindowedSortingIterator<>(getContext(), SAMEvidenceSource.maximumWindowSize(getContext(), getSamEvidenceSources(), getAssemblySource()), breakendCalls); Iterator<IdsvVariantContext> mergedIt = Iterators.mergeSorted(ImmutableList.of(bpit, nonbeIt), IdsvVariantContext.ByLocationStart); return new AutoClosingIterator<>(mergedIt, vcfReader, it); } protected void saveVcf(File file, Iterator<IdsvVariantContext> calls) throws IOException {
public void vcfTester(String inVcf){ // Credit: https://www.biostars.org/p/262943/ VCFFileReader r=new VCFFileReader(new File(inVcf)); CloseableIterator<VariantContext> t=r.iterator(); while(t.hasNext()){ t.next(); } t.close(); r.close(); }
compoundFilter.add(new HeterozygosityFilter(true, SAMPLE)); final Iterator<VariantContext> hetIterator = new FilteringVariantContextIterator(vcfReader.iterator(), compoundFilter);
static Queue<String> loadContigPositions(final File inputFile) { final VCFFileReader reader = new VCFFileReader(inputFile, false); final Queue<String> contigPositions = new LinkedList<String>(); final CloseableIterator<VariantContext> iterator = reader.iterator(); while (iterator.hasNext()) contigPositions.add(getContigPosition(iterator.next())); iterator.close(); reader.close(); return contigPositions; }
private void validateResultsForMultipleInputs(final File output, final List<Queue<String>> positionQueues) { final VCFFileReader outputReader = new VCFFileReader(output, false); final VariantContextComparator outputComparator = outputReader.getFileHeader().getVCFRecordComparator(); VariantContext last = null; final CloseableIterator<VariantContext> iterator = outputReader.iterator(); while (iterator.hasNext()) { final VariantContext outputContext = iterator.next(); final String position = getContigPosition(outputContext); for (final Queue<String> positionQueue : positionQueues) { if (position.equals(positionQueue.peek())) { positionQueue.poll(); break; } } if (last != null) Assert.assertTrue(outputComparator.compare(last, outputContext) <= 0); last = outputContext; } iterator.close(); for (final Queue<String> positionQueue : positionQueues) { Assert.assertEquals(positionQueue.size(), 0); } }
@Test(dataProvider = "structuralVariationsTestData") public void testExtractStructuralVariationsData(final File vcfFile) { VCFFileReader reader = null; CloseableIterator<VariantContext> iter = null; try { reader = new VCFFileReader(vcfFile , false ); iter = reader.iterator(); while(iter.hasNext()) { final VariantContext ctx = iter.next(); final StructuralVariantType st = ctx.getStructuralVariantType(); Assert.assertNotNull(st); } } finally { CloserUtil.close(iter); CloserUtil.close(reader); } }
/** * Checks the ordering and total number of variant context entries in the specified output VCF file. * Does NOT check explicitly that the VC genomic positions match exactly those from the inputs. We assume this behavior from other tests. * * @param output VCF file representing the output of SortVCF * @param expectedVariantContextCount the total number of variant context entries from all input files that were merged/sorted */ private void validateSortingResults(final File output, final int expectedVariantContextCount) { final VCFFileReader outputReader = new VCFFileReader(output, false); final VariantContextComparator outputComparator = outputReader.getFileHeader().getVCFRecordComparator(); VariantContext last = null; int variantContextCount = 0; final CloseableIterator<VariantContext> iterator = outputReader.iterator(); while (iterator.hasNext()) { final VariantContext outputContext = iterator.next(); if (last != null) Assert.assertTrue(outputComparator.compare(last, outputContext) <= 0); last = outputContext; variantContextCount++; } iterator.close(); Assert.assertEquals(variantContextCount, expectedVariantContextCount); } }
@Test(dataProvider = "goodInputVcfs") public void testJavaScript(final File input) throws Exception { final File out = VcfTestUtils.createTemporaryIndexedFile("filterVcfTestJS.", ".vcf"); final FilterVcf filterer = new FilterVcf(); filterer.INPUT = input; filterer.OUTPUT = out; filterer.JAVASCRIPT_FILE = quickJavascriptFilter("variant.getStart()%5 != 0"); final int retval = filterer.doWork(); Assert.assertEquals(retval, 0); //count the number of reads final int expectedNumber = 4; int count = 0; VCFFileReader in = new VCFFileReader(filterer.OUTPUT, false); CloseableIterator<VariantContext> iter = in.iterator(); while (iter.hasNext()) { final VariantContext ctx = iter.next(); count += (ctx.isFiltered() ? 1 : 0); } iter.close(); in.close(); Assert.assertEquals(count, expectedNumber); }