@Override protected VariantAnnotation featureValueOf(Variant actual) { return actual.getAnnotation(); } };
private boolean requireAnnotation(Variant variant) { if (this.forceAnnotation) { return true; } VariantAnnotation annotation = variant.getAnnotation(); if (annotation == null) { return true; } // Chromosome not set -> require annotation !!!! return StringUtils.isEmpty(annotation.getChromosome()); }
private boolean transcriptAnnotationUpdated(Variant variant, String ensemblTranscriptId) { if (variant.getAnnotation().getAdditionalAttributes() != null && variant.getAnnotation().getAdditionalAttributes().get("phasedTranscripts") != null && variant.getAnnotation().getAdditionalAttributes().get("phasedTranscripts") .getAttribute().containsKey(ensemblTranscriptId)) { return true; } return false; }
private boolean transcriptAnnotationUpdated(Variant variant, String ensemblTranscriptId) { if (variant.getAnnotation().getAdditionalAttributes() != null && variant.getAnnotation().getAdditionalAttributes().get("phasedTranscripts") != null && variant.getAnnotation().getAdditionalAttributes().get("phasedTranscripts") .getAttribute().containsKey(ensemblTranscriptId)) { return true; } return false; }
/** * Updates VariantAnnotation objects in variantAnnotationList. * * @param variantList List of Variant objects. variantList and variantAnnotationList must contain variants in the * SAME order: variantAnnotation at position i must correspond to variant i */ public void run(List<Variant> variantList) { for (int i = 0; i < variantList.size(); i++) { List<PopulationFrequency> populationFrequencies = getPopulationFrequencies(variantList.get(i)); // Update only if there are annotations for this variant. customAnnotation may be empty if the variant // exists in the vcf but the info field does not contain any of the required attributes if (populationFrequencies != null && populationFrequencies.size() > 0) { VariantAnnotation variantAnnotation = variantList.get(i).getAnnotation(); if (variantAnnotation != null) { // variantList and variantAnnotationList must contain variants in the SAME order: variantAnnotation // at position i must correspond to variant i variantAnnotation.setPopulationFrequencies(populationFrequencies); } } } }
private void flagTranscriptAnnotationUpdated(Variant variant, String ensemblTranscriptId) { Map<String, AdditionalAttribute> additionalAttributesMap = variant.getAnnotation().getAdditionalAttributes(); if (additionalAttributesMap == null) { additionalAttributesMap = new HashMap<>(); AdditionalAttribute additionalAttribute = new AdditionalAttribute(); Map<String, String> transcriptsSet = new HashMap<>(); transcriptsSet.put(ensemblTranscriptId, null); additionalAttribute.setAttribute(transcriptsSet); additionalAttributesMap.put("phasedTranscripts", additionalAttribute); variant.getAnnotation().setAdditionalAttributes(additionalAttributesMap); } else if (additionalAttributesMap.get("phasedTranscripts") == null) { AdditionalAttribute additionalAttribute = new AdditionalAttribute(); Map<String, String> transcriptsSet = new HashMap<>(); transcriptsSet.put(ensemblTranscriptId, null); additionalAttribute.setAttribute(transcriptsSet); additionalAttributesMap.put("phasedTranscripts", additionalAttribute); } else { additionalAttributesMap.get("phasedTranscripts").getAttribute().put(ensemblTranscriptId, null); } }
private void flagTranscriptAnnotationUpdated(Variant variant, String ensemblTranscriptId) { Map<String, AdditionalAttribute> additionalAttributesMap = variant.getAnnotation().getAdditionalAttributes(); if (additionalAttributesMap == null) { additionalAttributesMap = new HashMap<>(); AdditionalAttribute additionalAttribute = new AdditionalAttribute(); Map<String, String> transcriptsSet = new HashMap<>(); transcriptsSet.put(ensemblTranscriptId, null); additionalAttribute.setAttribute(transcriptsSet); additionalAttributesMap.put("phasedTranscripts", additionalAttribute); variant.getAnnotation().setAdditionalAttributes(additionalAttributesMap); } else if (additionalAttributesMap.get("phasedTranscripts") == null) { AdditionalAttribute additionalAttribute = new AdditionalAttribute(); Map<String, String> transcriptsSet = new HashMap<>(); transcriptsSet.put(ensemblTranscriptId, null); additionalAttribute.setAttribute(transcriptsSet); additionalAttributesMap.put("phasedTranscripts", additionalAttribute); } else { additionalAttributesMap.get("phasedTranscripts").getAttribute().put(ensemblTranscriptId, null); } }
private Variant getPreferredVariant(QueryResult<Variant> variantQueryResult) { if (variantQueryResult.getNumResults() > 1 && variantQueryResult.first().getAnnotation().getPopulationFrequencies() == null) { for (int i = 1; i < variantQueryResult.getResult().size(); i++) { if (variantQueryResult.getResult().get(i).getAnnotation().getPopulationFrequencies() != null) { return variantQueryResult.getResult().get(i); } } } return variantQueryResult.first(); }
private Variant getPreferredVariant(QueryResult<Variant> variantQueryResult) { if (variantQueryResult.getNumResults() > 1 && variantQueryResult.first().getAnnotation().getPopulationFrequencies() == null) { for (int i = 1; i < variantQueryResult.getResult().size(); i++) { if (variantQueryResult.getResult().get(i).getAnnotation().getPopulationFrequencies() != null) { return variantQueryResult.getResult().get(i); } } } return variantQueryResult.first(); }
private Collection<Variant> filterByScore(QueryResult<Variant> variantQueryResult, Predicate<List<Score>> predicate, Function<VariantAnnotation, List<Score>> mapper) { TreeSet<Variant> variants = new TreeSet<>(Comparator.comparing(Variant::getChromosome).thenComparing(Variant::getStart).thenComparing(Variant::toString)); for (Variant variant : variantQueryResult.getResult()) { List<Score> list = mapper.apply(variant.getAnnotation()); if (list == null) { list = Collections.emptyList(); } if (predicate.test(list)) { variants.add(variant); } } return variants; }
private Map<String, ConsequenceType> getConsequenceTypeMap (Variant variant){ Map<String, ConsequenceType> map = new HashMap<>(); if (variant.getAnnotation() != null && ListUtils.isNotEmpty(variant.getAnnotation().getConsequenceTypes())) { for (ConsequenceType consequenceType: variant.getAnnotation().getConsequenceTypes()) { if (StringUtils.isNotEmpty(consequenceType.getEnsemblTranscriptId())) { map.put(consequenceType.getEnsemblTranscriptId(), consequenceType); } } } return map; }
private boolean updateRocksDB(Variant variant) throws RocksDBException, IOException { byte[] key = getNormalisedKey(variant.getChromosome(), variant.getStart(), variant.getReference(), variant.getAlternate()); if (key != null) { VariantAnnotation variantAnnotation = getVariantAnnotation(key); // Add EvidenceEntry objects variantAnnotation.getTraitAssociation().addAll(variant.getAnnotation().getTraitAssociation()); // Check if drug info is available if (variant.getAnnotation().getDrugs() != null && !variant.getAnnotation().getDrugs().isEmpty()) { // Drug info is stored at the VariantAnnotation root if (variantAnnotation.getDrugs() == null) { variantAnnotation.setDrugs(variant.getAnnotation().getDrugs()); } else { variantAnnotation.getDrugs().addAll(variant.getAnnotation().getDrugs()); } } rdb.put(key, jsonObjectWriter.writeValueAsBytes(variantAnnotation)); return true; } return false; }
@Test public void testIncludeAll() { for (Variant variant : allVariants.getResult()) { assertThat(variant.getStudies(), not(is(Collections.emptyList()))); assertThat(variant.getStudies().get(0).getStats(), not(is(Collections.emptyList()))); assertThat(variant.getStudies().get(0).getFiles(), not(is(Collections.emptyList()))); assertThat(variant.getStudies().get(0).getSamplesData(), not(is(Collections.emptyList()))); assertNotNull(variant.getAnnotation()); } }
@Test public void testRelease() throws Exception { List<Variant> variants = query(new Query(), new QueryOptions()).getResult(); for (Variant variant : variants) { Integer minFileId = variant.getStudies().stream() .flatMap(s -> s.getFiles().stream()) .map(FileEntry::getFileId) .map(s -> s.substring(30, 35)) .map(Integer::valueOf) .min(Integer::compareTo) .orElse(0); assertTrue(minFileId > 0); int expectedRelease = (minFileId - 12877/*first file loaded*/) / 2/*each release contains 2 files*/ + 1/*base-1*/; int release = Integer.valueOf(variant.getAnnotation().getAdditionalAttributes().get("opencga").getAttribute().get("release")); assertEquals(expectedRelease, release); } }
private Map<String, Variant> buildVariantsIdx() throws Exception { VariantHadoopDBAdaptor dbAdaptor = getVariantStorageEngine().getDBAdaptor(); Map<String, Variant> variants = new HashMap<>(); System.out.println("Build Variant map"); for (Variant variant : dbAdaptor) { if (variant.getStudies().isEmpty()) { continue; } String v = variant.toString(); assertFalse(variants.containsKey(v)); variants.put(v, variant); VariantAnnotation a = variant.getAnnotation(); variant.setAnnotation(null); System.out.println(variant.toJson()); variant.setAnnotation(a); } System.out.println("End. size : " + variants.size()); return variants; }
private Response getConsequenceType(String snpId) { try { parseQueryParams(); VariantDBAdaptor variationDBAdaptor = dbAdaptorFactory.getVariationDBAdaptor(this.species, this.assembly); query.put(VariantDBAdaptor.QueryParams.ID.key(), snpId); queryOptions.put(QueryOptions.INCLUDE, "annotation.displayConsequenceType"); QueryResult<Variant> queryResult = variationDBAdaptor.get(query, queryOptions); QueryResult queryResult1 = new QueryResult(queryResult.getId(), queryResult.getDbTime(), queryResult.getNumResults(), queryResult.getNumTotalResults(), queryResult.getWarningMsg(), queryResult.getErrorMsg(), Collections.singletonList(queryResult.getResult().get(0).getAnnotation().getDisplayConsequenceType())); return createOkResponse(queryResult1); } catch (Exception e) { return createErrorResponse("getConsequenceTypeByPostMethod", e.toString()); } }
@Test public void checkAllAnnotated() throws Exception { for (Variant variant : variantStorageEngine.getDBAdaptor()) { assertNotNull(variant.toString(), variant.getAnnotation()); } }
@Test public void testInclude() { queryResult = query(new Query(), new QueryOptions(QueryOptions.INCLUDE, "studies")); assertEquals(allVariants.getResult().size(), queryResult.getResult().size()); for (Variant variant : queryResult.getResult()) { assertThat(variant.getStudies(), not(is(Collections.emptyList()))); assertThat(variant.getStudies().get(0).getStats(), not(is(Collections.emptyList()))); assertThat(variant.getStudies().get(0).getFiles(), not(is(Collections.emptyList()))); assertThat(variant.getStudies().get(0).getSamplesData(), not(is(Collections.emptyList()))); assertNull(variant.getAnnotation()); } queryResult = query(new Query(), new QueryOptions(QueryOptions.INCLUDE, "annotation")); assertEquals(allVariants.getResult().size(), queryResult.getResult().size()); for (Variant variant : queryResult.getResult()) { assertThat(variant.getStudies(), is(Collections.emptyList())); assertNotNull(variant.getAnnotation()); } }
@Test public void testExcludeAnnotation() { queryResult = query(new Query(), new QueryOptions(QueryOptions.EXCLUDE, "annotation")); assertEquals(allVariants.getResult().size(), queryResult.getResult().size()); VariantAnnotation defaultAnnotation = new VariantAnnotation(); defaultAnnotation.setConsequenceTypes(Collections.emptyList()); for (Variant variant : queryResult.getResult()) { assertThat(variant.getAnnotation(), anyOf(is((VariantAnnotation) null), is(defaultAnnotation))); } }
@Test public void testExcludeAnnotationParts() { List<Variant> allVariants = query(new Query(), new QueryOptions(QueryOptions.SORT, true)).getResult(); queryResult = query(new Query(), new QueryOptions(QueryOptions.SORT, true).append(QueryOptions.EXCLUDE, VariantField.ANNOTATION_XREFS)); assertEquals(allVariants.size(), queryResult.getResult().size()); List<Variant> result = queryResult.getResult(); for (int i = 0; i < result.size(); i++) { Variant expectedVariant = allVariants.get(i); Variant variant = result.get(i); assertEquals(expectedVariant.toString(), variant.toString()); assertNotNull(expectedVariant.getAnnotation()); assertNotNull(variant.getAnnotation()); VariantAnnotation expectedAnnotation = expectedVariant.getAnnotation(); VariantAnnotation annotation = variant.getAnnotation(); expectedAnnotation.setXrefs(null); expectedAnnotation.setId(null); assertEquals("\n" + expectedAnnotation + "\n" + annotation, expectedAnnotation, annotation); } }