diff --git a/cellbase-lib/src/main/java/org/opencb/cellbase/lib/variant/annotation/VariantAnnotationCalculator.java b/cellbase-lib/src/main/java/org/opencb/cellbase/lib/variant/annotation/VariantAnnotationCalculator.java index 1b86b49367..9563a629d1 100644 --- a/cellbase-lib/src/main/java/org/opencb/cellbase/lib/variant/annotation/VariantAnnotationCalculator.java +++ b/cellbase-lib/src/main/java/org/opencb/cellbase/lib/variant/annotation/VariantAnnotationCalculator.java @@ -18,13 +18,15 @@ import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.StringUtils; +import org.opencb.biodata.models.clinical.ClinicalAcmg; +import org.opencb.biodata.models.clinical.interpretation.VariantClassification; import org.opencb.biodata.models.core.*; import org.opencb.biodata.models.pharma.PharmaChemical; import org.opencb.biodata.models.variant.Variant; import org.opencb.biodata.models.variant.VariantBuilder; import org.opencb.biodata.models.variant.annotation.ConsequenceTypeMappings; -import org.opencb.biodata.models.variant.avro.GeneCancerAssociation; import org.opencb.biodata.models.variant.avro.*; +import org.opencb.biodata.models.variant.avro.GeneCancerAssociation; import org.opencb.biodata.tools.variant.VariantNormalizer; import org.opencb.biodata.tools.variant.exceptions.VariantNormalizerException; import org.opencb.cellbase.core.ParamConstants; @@ -39,6 +41,7 @@ import org.opencb.cellbase.lib.EtlCommons; import org.opencb.cellbase.lib.managers.*; import org.opencb.cellbase.lib.variant.VariantAnnotationUtils; +import org.opencb.cellbase.lib.variant.annotation.futures.FutureGenomicSequenceContextAnnotator; import org.opencb.cellbase.lib.variant.annotation.futures.FuturePharmacogenomicsAnnotator; import org.opencb.cellbase.lib.variant.annotation.futures.FutureSnpAnnotator; import org.opencb.cellbase.lib.variant.annotation.futures.FutureSpliceScoreAnnotator; @@ -68,6 +71,30 @@ public class VariantAnnotationCalculator { private static final String EMPTY_STRING = ""; private static final String ALTERNATE = "1"; + + // Include values + public static final String EXPRESSION_INCLUDE = "expression"; + public static final String GENE_DISEASE_INCLUDE = "geneDisease"; + public static final String DRUG_INTERACTION_INCLUDE = "drugInteraction"; + public static final String GENE_CONSTRAINTS_INCLUDE = "geneConstraints"; + public static final String MIRNA_TARGETS_INCLUDE = "mirnaTargets"; + public static final String CANCER_GENE_ASSOCIATION_INCLUDE = "cancerGeneAssociation"; + public static final String CANCER_HOTSPOTS_INCLUDE = "cancerHotspots"; + public static final String VARIATION_INCLUDE = "variation"; + public static final String POPULATION_FREQUENCIES_INCLUDE = "populationFrequencies"; + public static final String XREFS_INCLUDE = "xrefs"; + public static final String CONSERVATION_INCLUDE = "conservation"; + public static final String FUNCTIONAL_SCORE_INCLUDE = "functionalScore"; + @Deprecated + public static final String CLINICAL_INCLUDE = "clinical"; + public static final String TRAIT_ASSOCIATION_INCLUDE = "traitAssociation"; + public static final String REPEATS_INCLUDE = "repeats"; + public static final String CYTOBAND_INCLUDE = "cytoband"; + public static final String CONSEQUENCE_TYPE_INCLUDE = "consequenceType"; + public static final String PHARMACOGENOMICS_INCLUDE = "pharmacogenomics"; + public static final String HGVS_INCLUDE = "hgvs"; + public static final String GENOMIC_CONTEXT_INCLUDE = "genomicContext"; + private GenomeManager genomeManager; private GeneManager geneManager; private RegulatoryManager regulationManager; @@ -270,7 +297,7 @@ private List setGeneAnnotation(List geneList, Variant variant) VariantAnnotation variantAnnotation = variant.getAnnotation(); // TODO Remove expression data since is deprecated - if (annotatorSet.contains("expression")) { + if (annotatorSet.contains(EXPRESSION_INCLUDE)) { variantAnnotation.setGeneExpression(new ArrayList<>()); for (Gene gene : geneList) { // refseq genes don't have annotation (yet) @@ -280,7 +307,7 @@ private List setGeneAnnotation(List geneList, Variant variant) } } - if (annotatorSet.contains("geneDisease")) { + if (annotatorSet.contains(GENE_DISEASE_INCLUDE)) { variantAnnotation.setGeneTraitAssociation(new ArrayList<>()); Set visited = new HashSet<>(); for (Gene gene : geneList) { @@ -294,7 +321,7 @@ private List setGeneAnnotation(List geneList, Variant variant) } } - if (annotatorSet.contains("drugInteraction")) { + if (annotatorSet.contains(DRUG_INTERACTION_INCLUDE)) { variantAnnotation.setGeneDrugInteraction(new ArrayList<>()); for (Gene gene : geneList) { if (gene.getAnnotation() != null && gene.getAnnotation().getDrugs() != null) { @@ -303,7 +330,7 @@ private List setGeneAnnotation(List geneList, Variant variant) } } - if (annotatorSet.contains("geneConstraints")) { + if (annotatorSet.contains(GENE_CONSTRAINTS_INCLUDE)) { variantAnnotation.setGeneConstraints(new ArrayList<>()); for (Gene gene : geneList) { if (gene.getAnnotation() != null && gene.getAnnotation().getConstraints() != null) { @@ -312,7 +339,7 @@ private List setGeneAnnotation(List geneList, Variant variant) } } - if (annotatorSet.contains("mirnaTargets")) { + if (annotatorSet.contains(MIRNA_TARGETS_INCLUDE)) { variantAnnotation.setGeneMirnaTargets(new ArrayList<>()); for (Gene gene : geneList) { if (gene.getMirna() != null && gene.getMirna().getMatures() != null) { @@ -321,7 +348,7 @@ private List setGeneAnnotation(List geneList, Variant variant) } } - if (annotatorSet.contains("cancerGeneAssociation")) { + if (annotatorSet.contains(CANCER_GENE_ASSOCIATION_INCLUDE)) { variantAnnotation.setGeneCancerAssociations(new ArrayList<>()); Set visited = new HashSet<>(); for (Gene gene : geneList) { @@ -374,7 +401,7 @@ private List setGeneAnnotation(List geneList, Variant variant) } } - if (annotatorSet.contains("cancerHotspots")) { + if (annotatorSet.contains(CANCER_HOTSPOTS_INCLUDE)) { variantAnnotation.setCancerHotspots(new ArrayList<>()); Set visited = new HashSet<>(); for (Gene gene : geneList) { @@ -452,15 +479,13 @@ private List runAnnotationProcess(List normalizedVar // Object to be returned List variantAnnotationList = new ArrayList<>(normalizedVariantList.size()); - /* - * Next three async blocks calculate annotations using Futures, this will be calculated in a different thread. - * Once the main loop has finished then they will be stored. This provides a ~30% of performance improvement. - */ + // Next three async blocks calculate annotations using Futures, this will be calculated in a different thread. + // Once the main loop has finished then they will be stored. This provides a ~30% of performance improvement. FutureVariationAnnotator futureVariationAnnotator = null; Future>> variationFuture = null; List batchGeneList = getBatchGeneList(normalizedVariantList); - if (annotatorSet.contains("variation") || annotatorSet.contains("populationFrequencies")) { + if (annotatorSet.contains(VARIATION_INCLUDE) || annotatorSet.contains(POPULATION_FREQUENCIES_INCLUDE)) { futureVariationAnnotator = new FutureVariationAnnotator(normalizedVariantList, new QueryOptions("include", "id,annotation.populationFrequencies,annotation.additionalAttributes.dgvSpecificAttributes") .append("imprecise", imprecise), dataRelease.getRelease()); @@ -469,14 +494,14 @@ private List runAnnotationProcess(List normalizedVar FutureSnpAnnotator futureSnpAnnotator = null; Future>> snpFuture = null; - if (annotatorSet.contains("xrefs") && dataRelease.getCollections().containsKey(EtlCommons.SNP_COLLECTION_NAME)) { + if (annotatorSet.contains(XREFS_INCLUDE) && dataRelease.getCollections().containsKey(EtlCommons.SNP_COLLECTION_NAME)) { futureSnpAnnotator = new FutureSnpAnnotator(normalizedVariantList, dataRelease.getRelease(), variantManager, logger); snpFuture = CACHED_THREAD_POOL.submit(futureSnpAnnotator); } FutureConservationAnnotator futureConservationAnnotator = null; Future>> conservationFuture = null; - if (annotatorSet.contains("conservation")) { + if (annotatorSet.contains(CONSERVATION_INCLUDE)) { futureConservationAnnotator = new FutureConservationAnnotator(normalizedVariantList, QueryOptions.empty(), dataRelease.getRelease()); conservationFuture = CACHED_THREAD_POOL.submit(futureConservationAnnotator); @@ -484,7 +509,7 @@ private List runAnnotationProcess(List normalizedVar FutureVariantFunctionalScoreAnnotator futureVariantFunctionalScoreAnnotator = null; Future>> variantFunctionalScoreFuture = null; - if (annotatorSet.contains("functionalScore")) { + if (annotatorSet.contains(FUNCTIONAL_SCORE_INCLUDE)) { futureVariantFunctionalScoreAnnotator = new FutureVariantFunctionalScoreAnnotator(normalizedVariantList, QueryOptions.empty(), dataRelease.getRelease()); variantFunctionalScoreFuture = CACHED_THREAD_POOL.submit(futureVariantFunctionalScoreAnnotator); @@ -493,7 +518,7 @@ private List runAnnotationProcess(List normalizedVar FutureClinicalAnnotator futureClinicalAnnotator = null; Future>> clinicalFuture = null; // FIXME "clinical" is deprecated, replaced with traitAssociation - if (annotatorSet.contains("clinical") || annotatorSet.contains("traitAssociation")) { + if (annotatorSet.contains(CLINICAL_INCLUDE) || annotatorSet.contains(TRAIT_ASSOCIATION_INCLUDE)) { QueryOptions queryOptions = new QueryOptions(); queryOptions.add(ParamConstants.QueryParams.PHASE.key(), phased); queryOptions.add(ParamConstants.QueryParams.CHECK_AMINO_ACID_CHANGE.key(), checkAminoAcidChange); @@ -504,21 +529,21 @@ private List runAnnotationProcess(List normalizedVar FutureRepeatsAnnotator futureRepeatsAnnotator = null; Future>> repeatsFuture = null; - if (annotatorSet.contains("repeats")) { + if (annotatorSet.contains(REPEATS_INCLUDE)) { futureRepeatsAnnotator = new FutureRepeatsAnnotator(normalizedVariantList, dataRelease.getRelease()); repeatsFuture = CACHED_THREAD_POOL.submit(futureRepeatsAnnotator); } FutureCytobandAnnotator futureCytobandAnnotator = null; Future>> cytobandFuture = null; - if (annotatorSet.contains("cytoband")) { + if (annotatorSet.contains(CYTOBAND_INCLUDE)) { futureCytobandAnnotator = new FutureCytobandAnnotator(normalizedVariantList, QueryOptions.empty(), dataRelease.getRelease()); cytobandFuture = CACHED_THREAD_POOL.submit(futureCytobandAnnotator); } FutureSpliceScoreAnnotator futureSpliceScoreAnnotator = null; Future>> spliceScoreFuture = null; - if (annotatorSet.contains("consequenceType")) { + if (annotatorSet.contains(CONSEQUENCE_TYPE_INCLUDE)) { futureSpliceScoreAnnotator = new FutureSpliceScoreAnnotator(normalizedVariantList, dataRelease.getRelease(), apiKey, variantManager, logger); spliceScoreFuture = CACHED_THREAD_POOL.submit(futureSpliceScoreAnnotator); @@ -526,12 +551,19 @@ private List runAnnotationProcess(List normalizedVar FuturePharmacogenomicsAnnotator futurePharmacogenomicsAnnotator = null; Future>> pharmacogenomicsFuture = null; - if (annotatorSet.contains("pharmacogenomics") && dataRelease.getCollections().containsKey(EtlCommons.PHARMACOGENOMICS_DATA)) { + if (annotatorSet.contains(PHARMACOGENOMICS_INCLUDE) && dataRelease.getCollections().containsKey(EtlCommons.PHARMACOGENOMICS_DATA)) { futurePharmacogenomicsAnnotator = new FuturePharmacogenomicsAnnotator(normalizedVariantList, QueryOptions.empty(), dataRelease.getRelease(), pharmacogenomicsManager, logger); pharmacogenomicsFuture = CACHED_THREAD_POOL.submit(futurePharmacogenomicsAnnotator); } + FutureGenomicSequenceContextAnnotator contextAnnotator = null; + Future> contextFuture = null; + if (annotatorSet.contains(GENOMIC_CONTEXT_INCLUDE)) { + contextAnnotator = new FutureGenomicSequenceContextAnnotator(normalizedVariantList, dataRelease.getRelease(), genomeManager); + contextFuture = CACHED_THREAD_POOL.submit(contextAnnotator); + } + // We iterate over all variants to get the rest of the annotations and to create the VariantAnnotation objects Queue variantBuffer = new LinkedList<>(); long startTime = System.currentTimeMillis(); @@ -566,7 +598,7 @@ private List runAnnotationProcess(List normalizedVar // FOR INDELS // Given that the number of indels is expected to be negligible if compared to the number of SNVs, the // decision is to run it synchronously - if (annotatorSet.contains("hgvs")) { + if (annotatorSet.contains(HGVS_INCLUDE)) { try { // Decided to always set normalize = false for a number of reasons: // * was raising problems with the normalizer - it could potentially fail in weird multiallelic @@ -590,7 +622,7 @@ private List runAnnotationProcess(List normalizedVar } } - if (annotatorSet.contains("consequenceType")) { + if (annotatorSet.contains(CONSEQUENCE_TYPE_INCLUDE)) { try { List consequenceTypeList = getConsequenceTypeList(variant, affectedGenes, true, QueryOptions.empty(), dataRelease.getRelease()); @@ -645,10 +677,8 @@ private List runAnnotationProcess(List normalizedVar logger.debug("Main loop iteration annotation performance is {}ms for {} variants", System.currentTimeMillis() - startTime, normalizedVariantList.size()); - /* - * Now, hopefully the other annotations have finished and we can store the results. - * Method 'processResults' has been implemented in the same class for sanity. - */ + // Now, hopefully the other annotations have finished and we can store the results. + // Method 'processResults' has been implemented in the same class for sanity. if (futureVariationAnnotator != null) { futureVariationAnnotator.processResults(variationFuture, variantAnnotationList, annotatorSet); } @@ -676,15 +706,34 @@ private List runAnnotationProcess(List normalizedVar if (futurePharmacogenomicsAnnotator != null) { futurePharmacogenomicsAnnotator.processResults(pharmacogenomicsFuture, variantAnnotationList); } + if (contextAnnotator != null) { + contextAnnotator.processResults(contextFuture, variantAnnotationList); + } - // Not needed with newCachedThreadPool - // fixedThreadPool.shutdown(); + // ACMG, only if consequence type is required + if (annotatorSet.contains(CONSEQUENCE_TYPE_INCLUDE)) { + setAcmdPredictions(variantAnnotationList); + } logger.debug("Total batch annotation performance is {}ms for {} variants", System.currentTimeMillis() - globalStartTime, normalizedVariantList.size()); return variantAnnotationList; } + private static void setAcmdPredictions(List variantAnnotationList) { + for (VariantAnnotation variantAnnotation : variantAnnotationList) { + if (variantAnnotation != null && CollectionUtils.isNotEmpty(variantAnnotation.getConsequenceTypes())) { + for (ConsequenceType consequenceType : variantAnnotation.getConsequenceTypes()) { + List acmgs = VariantClassification.calculateAcmgClassification(consequenceType, variantAnnotation, + null); + if (CollectionUtils.isNotEmpty(acmgs)) { + consequenceType.setAcmg(acmgs.stream().map(ClinicalAcmg::getClassification).collect(Collectors.toList())); + } + } + } + } + } + public List getBatchGeneList(List variantList) throws QueryException, IllegalAccessException, CellBaseException { List regionList = variantListToRegionList(variantList); @@ -1181,9 +1230,11 @@ private Set getAnnotatorSet(QueryOptions queryOptions) { annotatorSet = new HashSet<>(includeList); } else { // 'expression' removed in CB 5.0 - annotatorSet = new HashSet<>(Arrays.asList("variation", "traitAssociation", "conservation", "functionalScore", - "consequenceType", "geneDisease", "drugInteraction", "geneConstraints", "mirnaTargets", "pharmacogenomics", - "cancerGeneAssociation", "cancerHotspots", "populationFrequencies", "repeats", "cytoband", "hgvs", "xrefs")); + annotatorSet = new HashSet<>(Arrays.asList(VARIATION_INCLUDE, TRAIT_ASSOCIATION_INCLUDE, CONSERVATION_INCLUDE, + FUNCTIONAL_SCORE_INCLUDE, CONSEQUENCE_TYPE_INCLUDE, GENE_DISEASE_INCLUDE, DRUG_INTERACTION_INCLUDE, + GENE_CONSTRAINTS_INCLUDE, MIRNA_TARGETS_INCLUDE, PHARMACOGENOMICS_INCLUDE, CANCER_GENE_ASSOCIATION_INCLUDE, + CANCER_HOTSPOTS_INCLUDE, POPULATION_FREQUENCIES_INCLUDE, REPEATS_INCLUDE, CYTOBAND_INCLUDE, HGVS_INCLUDE, + XREFS_INCLUDE, GENOMIC_CONTEXT_INCLUDE)); List excludeList = queryOptions.getAsStringList("exclude"); excludeList.forEach(annotatorSet::remove); } @@ -1199,25 +1250,25 @@ private List getIncludedGeneFields(Set annotatorSet) { "transcripts.exons.cdsEnd", "transcripts.exons.sequence", "transcripts.exons.phase", "transcripts.exons.exonNumber", "mirna", "transcripts.exons.genomicCodingStart", "transcripts.exons.genomicCodingEnd")); - if (annotatorSet.contains("expression")) { + if (annotatorSet.contains(EXPRESSION_INCLUDE)) { includeGeneFields.add("annotation.expression"); } - if (annotatorSet.contains("geneDisease")) { + if (annotatorSet.contains(GENE_DISEASE_INCLUDE)) { includeGeneFields.add("annotation.diseases"); } - if (annotatorSet.contains("drugInteraction")) { + if (annotatorSet.contains(DRUG_INTERACTION_INCLUDE)) { includeGeneFields.add("annotation.drugs"); } - if (annotatorSet.contains("geneConstraints")) { + if (annotatorSet.contains(GENE_CONSTRAINTS_INCLUDE)) { includeGeneFields.add("annotation.constraints"); } - if (annotatorSet.contains("mirnaTargets")) { + if (annotatorSet.contains(MIRNA_TARGETS_INCLUDE)) { includeGeneFields.add("annotation.targets"); } - if (annotatorSet.contains("cancerGeneAssociation")) { + if (annotatorSet.contains(CANCER_GENE_ASSOCIATION_INCLUDE)) { includeGeneFields.add("annotation.cancerAssociations"); } - if (annotatorSet.contains("cancerHotspots")) { + if (annotatorSet.contains(CANCER_HOTSPOTS_INCLUDE)) { includeGeneFields.add("annotation.cancerHotspots"); } return includeGeneFields; @@ -1596,7 +1647,7 @@ public void processResults(Future>> variationFu } } - if (annotatorSet.contains("populationFrequencies") && preferredVariant != null) { + if (annotatorSet.contains(POPULATION_FREQUENCIES_INCLUDE) && preferredVariant != null) { variantAnnotationList.get(i) .setPopulationFrequencies(preferredVariant.getAnnotation().getPopulationFrequencies()); } diff --git a/cellbase-lib/src/main/java/org/opencb/cellbase/lib/variant/annotation/futures/FutureGenomicSequenceContextAnnotator.java b/cellbase-lib/src/main/java/org/opencb/cellbase/lib/variant/annotation/futures/FutureGenomicSequenceContextAnnotator.java new file mode 100644 index 0000000000..fa701848ee --- /dev/null +++ b/cellbase-lib/src/main/java/org/opencb/cellbase/lib/variant/annotation/futures/FutureGenomicSequenceContextAnnotator.java @@ -0,0 +1,107 @@ +/* + * Copyright 2015-2020 OpenCB + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.opencb.cellbase.lib.variant.annotation.futures; + +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.time.StopWatch; +import org.opencb.biodata.models.core.GenomeSequenceFeature; +import org.opencb.biodata.models.core.Region; +import org.opencb.biodata.models.variant.Variant; +import org.opencb.biodata.models.variant.avro.GenomicSequenceContext; +import org.opencb.biodata.models.variant.avro.VariantAnnotation; +import org.opencb.biodata.models.variant.avro.VariantType; +import org.opencb.cellbase.lib.managers.GenomeManager; +import org.opencb.commons.datastore.core.QueryOptions; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.*; + +public class FutureGenomicSequenceContextAnnotator implements Callable> { + + // The context length is: [CONTEX_SIZE <- variant.start -> CONTEXT_SIZE] + private final int CONTEXT_SIZE = 10; + + private GenomeManager genomeManager; + + private List variantList; + private int dataRelease; + + private Logger logger = LoggerFactory.getLogger(this.getClass()); + + public FutureGenomicSequenceContextAnnotator(List variantList, int dataRelease, GenomeManager genomeManager) { + this.genomeManager = genomeManager; + + this.variantList = variantList; + this.dataRelease = dataRelease; + } + + @Override + public List call() throws Exception { + StopWatch stopWatch = StopWatch.createStarted(); + + GenomicSequenceContext genomicSequenceContext; + List resultList = new ArrayList<>(variantList.size()); + + logger.debug("Genomic sequence context queries ..."); + // Want to return only one CellBaseDataResult object per Variant + for (Variant variant : variantList) { + genomicSequenceContext = null; + if (VariantType.SNV != variant.getType() && VariantType.SNP != variant.getType()) { + int start = variant.getStart() - CONTEXT_SIZE; + if (start < 1) { + start = 1; + } + int end = variant.getStart() + CONTEXT_SIZE; + Region region = new Region(variant.getChromosome(), start, end); + logger.debug("Region {} for the genomic sequence context query", region); + GenomeSequenceFeature genomeSequenceFeature = genomeManager.getSequence(region, QueryOptions.empty(), dataRelease).first(); + if (genomeSequenceFeature != null) { + genomicSequenceContext = new GenomicSequenceContext(genomeSequenceFeature.getStart(), genomeSequenceFeature.getEnd(), + genomeSequenceFeature.getSequence()); + } + logger.debug("Genomic sequence context = {}", genomicSequenceContext); + } + resultList.add(genomicSequenceContext); + } + logger.info("Genomic sequence context queries performance in {} ms for {} variants", stopWatch.getTime(TimeUnit.MILLISECONDS), + variantList.size()); + return resultList; + } + + public void processResults(Future> contextFuture, List variantAnnotationList) + throws InterruptedException, ExecutionException { + List contextResults; + try { + contextResults = contextFuture.get(30, TimeUnit.SECONDS); + } catch (TimeoutException e) { + contextFuture.cancel(true); + throw new ExecutionException("Unable to finish genomic sequence context query on time", e); + } + + if (CollectionUtils.isNotEmpty(contextResults)) { + for (int i = 0; i < variantAnnotationList.size(); i++) { + GenomicSequenceContext context = contextResults.get(i); + if (context != null) { + variantAnnotationList.get(i).setGenomicSequenceContext(context); + } + } + } + } +} diff --git a/cellbase-lib/src/test/java/org/opencb/cellbase/lib/impl/core/VariantAnnotationCalculatorTest.java b/cellbase-lib/src/test/java/org/opencb/cellbase/lib/impl/core/VariantAnnotationCalculatorTest.java index b973f0b996..6f835a8f04 100644 --- a/cellbase-lib/src/test/java/org/opencb/cellbase/lib/impl/core/VariantAnnotationCalculatorTest.java +++ b/cellbase-lib/src/test/java/org/opencb/cellbase/lib/impl/core/VariantAnnotationCalculatorTest.java @@ -457,14 +457,14 @@ public void testImpreciseConsequenceTypeAnnotation() throws Exception { assertThat(consequenceTypeResult.getResults(), CoreMatchers.hasItems(new ConsequenceType("FAM138A", "ENSG00000237613", "ENST00000417324", "ENSG00000237613", - "ENST00000417324", null, "-", "lincRNA", "ensembl", null, null, + "ENST00000417324", null, "-", "lincRNA", "ensembl", null, null, null, Arrays.asList("basic"), null, null, null, null, Arrays.asList(new SequenceOntologyTerm("SO:0001889", "transcript_amplification"))), new ConsequenceType("FAM138A", "ENSG00000237613", "ENST00000461467", "ENSG00000237613", "ENST00000461467", null, "-", "lincRNA", "ensembl", null, null, - null, null, null, + null, null, null, null, null, null, Arrays.asList(new SequenceOntologyTerm("SO:0001889", "transcript_amplification"))))); @@ -500,13 +500,13 @@ public void testImpreciseConsequenceTypeAnnotation() throws Exception { assertThat(consequenceTypeResult.getResults(), CoreMatchers.hasItems(new ConsequenceType("FAM138A", "ENSG00000237613", "ENST00000417324", "ENSG00000237613", - "ENST00000417324", null, "-", "lincRNA", "ensembl", null, null, + "ENST00000417324", null, "-", "lincRNA", "ensembl", null, null, null, Arrays.asList("basic"), null, null, null, null, Arrays.asList(new SequenceOntologyTerm("SO:0001893", "transcript_ablation"))), new ConsequenceType("FAM138A", "ENSG00000237613", "ENST00000461467", "ENSG00000237613", - "ENST00000461467", null, "-", "lincRNA", "ensembl", null, null, + "ENST00000461467", null, "-", "lincRNA", "ensembl", null, null, null, null, null, null, null, null, Arrays.asList(new SequenceOntologyTerm("SO:0001893", "transcript_ablation"))))); diff --git a/pom.xml b/pom.xml index 43ff005dea..7b1e765a62 100644 --- a/pom.xml +++ b/pom.xml @@ -23,8 +23,8 @@ ${project.version} - 5.7.0-SNAPSHOT - 3.7.0-SNAPSHOT + 7.0.0-SNAPSHOT + 5.0.0-SNAPSHOT 0.1.0 2.11.4 1.9.13