private Variant getVariantFromInsertion(String chromosome) throws ParseException { Variant variant; try { String insertion = change.split("(ins)")[1]; String referenceString = "-"; variant = new Variant(chromosome, start, stop, referenceString, insertion); } catch (ArrayIndexOutOfBoundsException e) { throw new ParseException("Hgvs insertion malformed: " + change, change.length()); } return variant; }
public static Variant getVariantFromArchiveVariantColumn(String chromosome, byte[] column) { String[] split = Bytes.toString(column).split("_", -1); if (split.length != 5) { return null; } else { return new Variant(chromosome, Integer.valueOf(split[2]), split[3], split[4]); } } }
@Override public List<Variant> read() { String line = null; try { line = reader.readLine(); } catch (IOException e) { e.printStackTrace(); } return line != null ? Collections.singletonList(new Variant(jsonObjectMapper.convertValue(JSON.parse(line), VariantAvro.class))) : null; }
@Override public List<Variant> read(int batchSize) { List<Variant> batch = new ArrayList<>(batchSize); List<VariantAvro> read = avroDataReader.read(batchSize); for (VariantAvro variantAvro : read) { Variant variant = new Variant(variantAvro); batch.add(variant); } return addSamplesPosition(batch); }
@Test public void testStructuralVariantRowKey() throws Exception { checkVariantRowKeyGeneration(new Variant("5:110-510:-:<DEL>")); checkVariantRowKeyGeneration(new Variant("5:100<110<120-500<510<520:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA:-")); checkVariantRowKeyGeneration(new Variant("5:100<110<120-500<510<520:A:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")); checkVariantRowKeyGeneration(new Variant("5:100<110<120-500<510<520:A:<DEL>")); checkVariantRowKeyGeneration(new Variant("5:100<110<120-500<510<520:-:<DEL>")); checkVariantRowKeyGeneration(new Variant("5:100<110<120-500<510<520:A:<CN5>")); checkVariantRowKeyGeneration(new Variant("5:100<110<120-500<510<520:-:<CN5>")); checkVariantRowKeyGeneration(new Variant("5:100:A:A]:chr5:234]")); }
@Test public void testVariantRowKey() throws Exception { checkVariantRowKeyGeneration(new Variant("5", 21648, "A", "T")); checkVariantRowKeyGeneration(new Variant("5", 21648, "AAAAAA", "T")); checkVariantRowKeyGeneration(new Variant("5", 21648, "A", "")); checkVariantRowKeyGeneration(new Variant("5", 21648, "AAT", "TTT")); checkVariantRowKeyGeneration(new Variant("X", 21648, "", "TTT")); checkVariantRowKeyGeneration(new Variant("MT", 21648, "", "")); }
private List<Variant> createEmptyVariantList(List<VariantAnnotation> variantAnnotationList) { List<Variant> newVariantList = new ArrayList<>(variantAnnotationList.size()); for (VariantAnnotation variantAnnotation : variantAnnotationList) { Variant variant = new Variant(variantAnnotation.getChromosome(), variantAnnotation.getStart(), variantAnnotation.getEnd(), variantAnnotation.getReference(), variantAnnotation.getAlternate()); variant.resetType(); variant.resetLength(); newVariantList.add(variant); } return newVariantList; }
@Test public void testOverlapsWith() { assertTrue(FillGapsTask.overlapsWith(new Variant("1:100:T:-"), "1", 100, 100)); Variant variant = new Variant("1:100:-:T"); assertTrue(FillGapsTask.overlapsWith(variant, "1", variant.getStart(), variant.getEnd())); variant = new Variant("1:100:-:TTTTT"); assertFalse(FillGapsTask.overlapsWith(variant, "1", 102, 102)); }
@Test public void testSkipVariant() throws VariantAnnotatorException { ObjectMap options = new ObjectMap(VariantAnnotationManager.ANNOTATOR, VariantAnnotatorFactory.AnnotationSource.OTHER.toString()) .append(VariantAnnotationManager.VARIANT_ANNOTATOR_CLASSNAME, TestCellBaseRestVariantAnnotator.class.getName()); VariantAnnotator variantAnnotator = VariantAnnotatorFactory.buildVariantAnnotator(storageConfiguration, storageConfiguration.getDefaultStorageEngineId(), projectMetadata, options); assertThat(variantAnnotator, is(instanceOf(TestCellBaseRestVariantAnnotator.class))); TestCellBaseRestVariantAnnotator testAnnotator = (TestCellBaseRestVariantAnnotator) variantAnnotator; testAnnotator.skip("10:1000:A:C"); List<VariantAnnotation> annotate = testAnnotator.annotate(Arrays.asList(new Variant("10:999:A:C"), new Variant("10:1000:A:C"), new Variant("10:1001:A:C"))); assertEquals(2, annotate.size()); }
@Test public void indel() { // Indel Variant v = new Variant("1", 1000, 1002, "", "CA"); assertEquals(" 1: 1000::CA", converter.buildId(v)); }
public void writeVariant(MongoDBVariantStageConverterTask converterTask, MongoDBVariantStageLoader loader, String variantStr) { Variant variant = new Variant(variantStr); variant.setNames(Collections.emptyList()); StudyEntry studyEntry = new StudyEntry("1", "1"); studyEntry.setFormat(Collections.emptyList()); variant.addStudyEntry(studyEntry); variantMap.put(variant.getChromosome(), variant); loader.write(converterTask.apply(Collections.singletonList(variant))); }
@Test public void snv() { // SNV Variant v = new Variant("1", 1000, 1000, "A", "C"); assertEquals(" 1: 1000:A:C", converter.buildId(v)); }
@Test public void sv() { // Structural String alt = "ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT"; Variant v = new Variant("1", 1000, 1002, "TAG", alt); assertEquals(" 1: 1000:TAG:" + new String(CryptoUtils.encryptSha1(alt)), converter.buildId(v)); }
public static Variant asVariant(Variant v) { Variant variant = new Variant(v.getChromosome(), v.getStart(), v.getEnd(), v.getReference(), v.getAlternate(), v.getStrand()); variant.setType(v.getType()); return variant; }
private Variant createVariantSecAlt(String varString, String secAlt) { Variant secAltVar = new Variant(secAlt); Variant variant = new Variant(varString); StudyEntry se = new StudyEntry("1"); AlternateCoordinate ac = new AlternateCoordinate( secAltVar.getChromosome(), secAltVar.getStart(), secAltVar.getEnd(), secAltVar.getReference(), secAltVar.getAlternate(), secAltVar.getType()); se.setSecondaryAlternates(Collections.singletonList(ac)); variant.setStudies(Collections.singletonList(se)); return variant; }
public static Matcher<VariantAnnotation> at(final String variant) { Variant v = new Variant(variant); return allOf(with("chromosome", VariantAnnotation::getChromosome, is(v.getChromosome())), with("position", VariantAnnotation::getStart, is(v.getStart())), with("reference", VariantAnnotation::getReference, is(v.getReference())), with("alternate", VariantAnnotation::getAlternate, is(v.getAlternate())) ); }
@Test public void testAlleleSha1WithColons() { // This allele, in SHA1 mode has 4 colons, so the parser thinks it is a structural variant String alt = "CTATATTTTATATAAACTATATTTTATATGTATATGTGTGTATACTATATTTTATATACTATACTATAGA"; Variant v = new Variant("1:1000:-:" + alt); assertEquals(SV_SPLIT_LENGTH - 1, StringUtils.countMatches(converter.buildId(v), ':')); assertEquals(v, converter.buildVariant(converter.buildId(v), 999, "", alt)); }
@Test public void insertion() { // INS Variant v = new Variant("1:1000:-:AAAAA...TTTT"); assertEquals(" 1: 1000::<INS>_AAAAA_TTTT::::", converter.buildId(v)); assertEquals(v, converter.buildVariant(converter.buildId(v), 999, "", "<INS>_AAAAA_TTTT")); v.getSv().setCiStartLeft(999); v.getSv().setCiStartRight(1010); assertEquals(" 1: 1000::<INS>_AAAAA_TTTT:999:1010::", converter.buildId(v)); assertEquals(v, converter.buildVariant(converter.buildId(v), 999, "", "<INS>_AAAAA_TTTT")); }