Java Code Examples for htsjdk.variant.vcf.VCFHeader#getInfoHeaderLine()

private Comparable<?> parseNumericInfoAttributeValue(final VCFHeader vcfHeader, final String key, final String stringValue) {
    final VCFInfoHeaderLine infoLine = vcfHeader.getInfoHeaderLine(key);
    if (infoLine == null) {
        oneShotHeaderLineLogger.warn(String.format("At least one attribute was found (%s) for which there is no corresponding header line", key));
        if (stringValue.contains(".")) {
            return Double.parseDouble(stringValue);
        } else {
            return Integer.parseInt(stringValue);
        }
    }
    switch (infoLine.getType()) {
        case Integer:
            return Integer.parseInt(stringValue);
        case Float:
            return Double.parseDouble(stringValue);
        default:
            throw new NumberFormatException(
                    String.format(
                            "The VCF header specifies type %s type for INFO attribute key %s, but a numeric value is required",
                            infoLine.getType().name(),
                            key)
            );
    }
}
 

@Override
public void onTraversalStart() {
    final VCFHeader vcfHeader = getHeaderForVariants();

    final VCFInfoHeaderLine funcotationHeaderLine = vcfHeader.getInfoHeaderLine(VcfOutputRenderer.FUNCOTATOR_VCF_FIELD_NAME);
    if (funcotationHeaderLine != null) {
        funcotationKeys = FuncotatorUtils.extractFuncotatorKeysFromHeaderDescription(funcotationHeaderLine.getDescription());
        outputVcfWriter = createVCFWriter(outputFile);
        vcfHeader.addMetaDataLine(new VCFFilterHeaderLine(FilterFuncotationsConstants.NOT_CLINSIG_FILTER,
                FilterFuncotationsConstants.NOT_CLINSIG_FILTER_DESCRIPTION));
        vcfHeader.addMetaDataLine(new VCFInfoHeaderLine(FilterFuncotationsConstants.CLINSIG_INFO_KEY, 1,
                VCFHeaderLineType.String, FilterFuncotationsConstants.CLINSIG_INFO_KEY_DESCRIPTION));
        outputVcfWriter.writeHeader(vcfHeader);
    } else {
        throw new UserException.BadInput("Could not extract Funcotation keys from " +
                VcfOutputRenderer.FUNCOTATOR_VCF_FIELD_NAME + " field in input VCF header.");
    }

    registerFilters();
}
 

private void assertEqualVariantFiles(final File outputFile, final String eColiExpectedOut) {
    // Get the actual data:
    final Pair<VCFHeader, List<VariantContext>> actualVcfInfo               = VariantContextTestUtils.readEntireVCFIntoMemory(outputFile.getAbsolutePath());
    final List<VariantContext>                  actualVariantContexts       = actualVcfInfo.getRight();
    final VCFHeader                             actualVcfHeader             = actualVcfInfo.getLeft();
    final VCFInfoHeaderLine                     actualFuncotationHeaderLine = actualVcfHeader.getInfoHeaderLine(VcfOutputRenderer.FUNCOTATOR_VCF_FIELD_NAME);

    // Get the expected data:
    final Pair<VCFHeader, List<VariantContext>> expectedVcfInfo               = VariantContextTestUtils.readEntireVCFIntoMemory(new File(eColiExpectedOut).getAbsolutePath());
    final List<VariantContext>                  expectedVariantContexts       = expectedVcfInfo.getRight();
    final VCFHeader                             expectedVcfHeader             = expectedVcfInfo.getLeft();
    final VCFInfoHeaderLine                     expectedFuncotationHeaderLine = expectedVcfHeader.getInfoHeaderLine(VcfOutputRenderer.FUNCOTATOR_VCF_FIELD_NAME);

    // Check that they're equal:
    Assert.assertEquals(actualFuncotationHeaderLine, expectedFuncotationHeaderLine);
    VariantContextTestUtils.assertEqualVariants(actualVariantContexts, expectedVariantContexts);
}
 

@VisibleForTesting
static Map<String, ListValue> getInfo(VariantContext vc, VCFHeader header) {
  Map<String, ListValue> toReturn = new HashMap<>();

  for (Map.Entry<String, Object> entry : vc.getAttributes().entrySet()) {
    String currKey = entry.getKey();
    VCFInfoHeaderLine metaData = header.getInfoHeaderLine(currKey);

    // All info fields must have a corresponding header field.
    if (metaData == null) {
      logger.log(Level.WARNING, String.format("Could not find matching VCF header field, "
          + "skipping info field %s", currKey));
      continue;
    }

    Object currObject = entry.getValue();
    ListValue.Builder listValueBuilder = ListValue.newBuilder();

    VCFHeaderLineType type = metaData.getType();
    if (!(currObject instanceof List)) {
      toReturn.put(currKey,
          listValueBuilder.addValues(createTypedValue(type, currObject)).build());
      continue;
    }

    List<Object> currObjectList = (List<Object>) currObject;
    for (Object currObj : currObjectList) {
      listValueBuilder.addValues(createTypedValue(type, currObj));
    }
    toReturn.put(currKey, listValueBuilder.build());
  }

  return toReturn;
}
 

@Test(enabled = enableFullScaleValidationTest,
      groups = {"funcotatorValidation"},
      dataProvider = "provideForLargeDataValidationTest")
public void largeDataValidationTest(final String inputVcfName,
                                    final String referencePath,
                                    final String referenceVersion,
                                    final String dataSourcesPath,
                                    final boolean isDsEnvironmentPath) throws IOException {

    // Get our main test folder path from our environment:
    final String testFolderInputPath = getFuncotatorLargeDataValidationTestInputPath();

    long startTime = 0, endTime = 0;
    final long overallStartTime = System.nanoTime();

    final String outFileBaseName = inputVcfName + ".funcotator";

    final String dataSourcesPathString;
    if (isDsEnvironmentPath) {
        dataSourcesPathString = getFuncotatorLargeDataValidationTestInputPath() + dataSourcesPath;
    }
    else {
        dataSourcesPathString = dataSourcesPath;
    }

    for (final FuncotatorArgumentDefinitions.OutputFormatType outFormat : FuncotatorArgumentDefinitions.OutputFormatType.values()) {

        startTime = System.nanoTime();

        final File outputFile;
        if (outFormat == FuncotatorArgumentDefinitions.OutputFormatType.VCF) {
            outputFile = getOutputFile(outFileBaseName, outFormat.toString().toLowerCase());
        } else {
            outputFile = getOutputFile(outFileBaseName + ".maf", "tsv");
        }

        final ArgumentsBuilder arguments = createBaselineArgumentsForFuncotator(
                testFolderInputPath + inputVcfName,
                outputFile,
                referencePath,
                dataSourcesPathString,
                referenceVersion,
                outFormat,
                true);

        // Add our manual annotations to the arguments:
        addManualAnnotationsToArguments(arguments);

        // Run the tool with our args:
        runCommandLine(arguments);

        endTime = System.nanoTime();

        logger.warn("  Elapsed Time (" + outFormat.toString() + "): " + (endTime - startTime) / 1e9 + "s");

        // Perform a simple validation if the file was a VCF:
        if ( outFormat == FuncotatorArgumentDefinitions.OutputFormatType.VCF) {

            try ( final FeatureDataSource<VariantContext> vcfReader = new FeatureDataSource<>(outputFile.getAbsolutePath()) ) {
                Assert.assertTrue(vcfReader.getHeader() instanceof VCFHeader, "Header is not a VCFHeader!");
                final VCFHeader vcfHeader = (VCFHeader)vcfReader.getHeader();

                final VCFInfoHeaderLine funcotationHeaderLine = vcfHeader.getInfoHeaderLine(VcfOutputRenderer.FUNCOTATOR_VCF_FIELD_NAME);
                final String[] funcotationFieldNames = FuncotatorUtils.extractFuncotatorKeysFromHeaderDescription(funcotationHeaderLine.getDescription());

                validateFuncotationsOnVcf(vcfReader, funcotationFieldNames);

            }
        }
    }

    logger.warn("Total Elapsed Time: " + (endTime - overallStartTime) / 1e9 + "s");
}
 

@Test
public void testVcfDatasourceAccountsForAltAlleles() {
    final FuncotatorArgumentDefinitions.OutputFormatType vcfOutputFormatType = FuncotatorArgumentDefinitions.OutputFormatType.VCF;
    final File vcfOutputFile = getOutputFile(vcfOutputFormatType);

    final ArgumentsBuilder arguments = createBaselineArgumentsForFuncotator(
            PIK3CA_VCF_HG19_ALTS,
            vcfOutputFile,
            b37Chr3Ref,
            DS_PIK3CA_DIR,
            FuncotatorTestConstants.REFERENCE_VERSION_HG19,
            vcfOutputFormatType,
            false);

    // We need this argument since we are testing on a subset of b37
    arguments.add(FuncotatorArgumentDefinitions.FORCE_B37_TO_HG19_REFERENCE_CONTIG_CONVERSION, true);

    runCommandLine(arguments);

    final Pair<VCFHeader, List<VariantContext>> vcfInfo = VariantContextTestUtils.readEntireVCFIntoMemory(vcfOutputFile.getAbsolutePath());
    final List<VariantContext> variantContexts = vcfInfo.getRight();
    Assert.assertTrue(variantContexts.size() > 0);
    final VCFHeader vcfHeader = vcfInfo.getLeft();
    final VCFInfoHeaderLine funcotationHeaderLine = vcfHeader.getInfoHeaderLine(VcfOutputRenderer.FUNCOTATOR_VCF_FIELD_NAME);
    final String[] funcotationKeys = FuncotatorUtils.extractFuncotatorKeysFromHeaderDescription(funcotationHeaderLine.getDescription());

    // The first variant context should have clinvar annotations, since it hit on the alt allele.  None of the rest.
    // This test assumes that each test variant context has only one alt allele.
    // The rest should not have any clinvar hits.
    for (int i = 0; i < variantContexts.size(); i++) {
        final String gtString = (i == 0) ? "MedGen:C0027672,SNOMED_CT:699346009" : "";
        final Map<Allele, FuncotationMap> alleleToFuncotationMap = FuncotatorUtils.createAlleleToFuncotationMapFromFuncotationVcfAttribute(funcotationKeys,
                variantContexts.get(i), "Gencode_19_annotationTranscript", "TEST");
        Assert.assertEquals(alleleToFuncotationMap.entrySet().size(), 1, "Found more than 1 alternate allele!");

        final FuncotationMap funcotationMap = alleleToFuncotationMap.values().iterator().next();
        Assert.assertEquals(funcotationMap.getTranscriptList().size(), 1, "Found more than 1 funcotation!");
        Assert.assertTrue(funcotationMap.getTranscriptList().stream().noneMatch(k -> k.equals(FuncotationMap.NO_TRANSCRIPT_AVAILABLE_KEY)), "Found a funcotation with an unknown transcript name: " + FuncotationMap.NO_TRANSCRIPT_AVAILABLE_KEY);
        Assert.assertTrue(funcotationMap.getTranscriptList().stream().noneMatch(StringUtils::isEmpty), "Found a funcotation with an empty transcript!");
        final List<Funcotation> funcotations = funcotationMap.get(funcotationMap.getTranscriptList().get(0));
        Assert.assertEquals(funcotations.size(), 1, "Found more than one funcotation in the funcotation map!");
        final Funcotation funcotation = funcotations.get(0);

        Assert.assertEquals(funcotation.getField("dummy_ClinVar_VCF_CLNDISDB"), FuncotatorUtils.sanitizeFuncotationFieldForVcf(gtString), "Field (dummy_ClinVar_VCF_CLNDISDB) was unsanititzed: " + funcotation.getField("dummy_ClinVar_VCF_CLNDISDB"));
    }
}
 

@Test
public void testCanAnnotateSpanningDeletions() {
    final FuncotatorArgumentDefinitions.OutputFormatType outputFormatType = FuncotatorArgumentDefinitions.OutputFormatType.VCF;
    final File outputFile = getOutputFile(outputFormatType);

    final ArgumentsBuilder arguments = createBaselineArgumentsForFuncotator(
            SPANNING_DEL_VCF,
            outputFile,
            hg38Chr3Ref,
            DS_PIK3CA_DIR,
            FuncotatorTestConstants.REFERENCE_VERSION_HG38,
            outputFormatType,
            false);

    runCommandLine(arguments);

    final Pair<VCFHeader, List<VariantContext>> vcfInfo = VariantContextTestUtils.readEntireVCFIntoMemory(outputFile.getAbsolutePath());
    final List<VariantContext> variantContexts = vcfInfo.getRight();
    Assert.assertTrue(variantContexts.size() > 0);
    final VCFHeader vcfHeader = vcfInfo.getLeft();
    final VCFInfoHeaderLine funcotationHeaderLine = vcfHeader.getInfoHeaderLine(VcfOutputRenderer.FUNCOTATOR_VCF_FIELD_NAME);
    final String[] funcotationKeys = FuncotatorUtils.extractFuncotatorKeysFromHeaderDescription(funcotationHeaderLine.getDescription());

    final int NUM_VARIANTS = 10;
    Assert.assertEquals(variantContexts.size(), NUM_VARIANTS);
    Assert.assertEquals(variantContexts.stream().filter(v -> v.hasAllele(Allele.SPAN_DEL)).count(), NUM_VARIANTS);

    for (final VariantContext vc : variantContexts) {
        final Map<Allele, FuncotationMap> alleleToFuncotationMap = FuncotatorUtils.createAlleleToFuncotationMapFromFuncotationVcfAttribute(funcotationKeys,
                vc, "Gencode_28_annotationTranscript", "TEST");

        // Make sure that all spanning deletions are funcotated with could not determine and that the others are something else.
        for (final Allele allele : alleleToFuncotationMap.keySet()) {
            final List<String> txIds = alleleToFuncotationMap.get(allele).getTranscriptList();
            for (final String txId : txIds) {
                if (allele.equals(Allele.SPAN_DEL)) {
                    Assert.assertEquals(alleleToFuncotationMap.get(allele).get(txId).get(0).getField("Gencode_28_variantClassification"), GencodeFuncotation.VariantClassification.COULD_NOT_DETERMINE.toString());
                    Assert.assertEquals(alleleToFuncotationMap.get(allele).get(txId).get(0).getField("Gencode_28_variantType"), GencodeFuncotation.VariantType.NA.toString());
                } else {
                    Assert.assertNotEquals(alleleToFuncotationMap.get(allele).get(txId).get(0).getField("Gencode_28_variantClassification"), GencodeFuncotation.VariantClassification.COULD_NOT_DETERMINE.toString());
                }
            }
        }
    }
}