@Override protected List<String> encodeVariants(List<Variant> variants) { List<String> outputBatch = new ArrayList<>(variants.size() * 2); for (Variant variant : variants) { try { String e = variant.toJson(); outputBatch.add(e); } catch (Exception e) { logger.error("Error parsing variant: {}", variant); throw e; } } return outputBatch; }
private void printJsonResult(VariantDBIterator variantDBIterator, OutputStream outputStream) throws IOException { while (variantDBIterator.hasNext()) { Variant variant = variantDBIterator.next(); outputStream.write(variant.toJson().getBytes()); outputStream.write('\n'); } }
@Override public Binary convertToStorageType(Variant variant) { byte[] data = variant.toJson().getBytes(); try { data = CompressionUtils.compress(data); } catch (IOException e) { throw new UncheckedIOException(e); } return new Binary(data); } }
@Test public void resolveRefOverlap() throws Exception { Variant a = getVariant("2:10048155-10048156:", "PASS", "220", "0/0"); a.setType(NO_VARIATION); Variant b = getVariant("2:10048155:AAA:-", "PASS", "220", "0/1"); System.out.println("a.toString() = " + a.toJson()); System.out.println("b.toString() = " + b.toJson()); Collection<Variant> resolved = new VariantLocalConflictResolver().resolveConflicts(Arrays.asList(a, b)); resolved.forEach(res -> System.out.println("res.toJson() = " + res.toJson())); assertEquals(1, resolved.size()); }
@Test public void testConvertToDataModelTypeWithoutFiles() { DocumentToVariantConverter converter = new DocumentToVariantConverter(); Variant converted = converter.convertToDataModelType(mongoVariant); variant.setStudies(Collections.<StudyEntry>emptyList()); assertEquals("\n" + variant.toJson() + "\n" + converted.toJson(), variant, converted); }
@Test public void getMissingRegionsAfterOutside() throws Exception { Variant a = getVariant("1:1000:A:T"); a.setType(NO_VARIATION); Variant b = getVariant("1:1002:A:T"); b.setType(NO_VARIATION); Variant snp = getVariant("1:1003:A:T"); System.out.println("a = " + a.toJson()); System.out.println("b = " + b.toJson()); System.out.println("snp = " + snp.toJson()); List<Pair<Integer, Integer>> missingRegions = VariantLocalConflictResolver.getMissingRegions(Arrays.asList (new Variant[]{a, b}), snp); System.out.println("missingRegions = " + missingRegions); assertEquals(1, missingRegions.size()); }
T missingValue = missingValues.get(0); if (missingValue instanceof Variant) { System.out.println("missing " + ((Variant) missingValue).toJson()); for (T extraValue : extraValues) { if (((Variant) extraValue).sameGenomicVariant(missingValue)) { System.out.println("extra " + ((Variant) extraValue).toJson());
@Test public void resolve_DEL_DEL_SEC_ALT_normalized() throws Exception { List<Variant> normalized; normalizer.setGenerateReferenceBlocks(false); Variant a = getVariant("1:99:N:NGG,NGA", "lowqual", "392", "1/2"); normalized = normalizer.apply(Collections.singletonList(a)); Variant b = getVariant("1:99:N:NGG,NGT", "PASS", "391", "1/2"); normalized.addAll(normalizer.apply(Collections.singletonList(b))); List<Variant> resolved = new VariantLocalConflictResolver().resolveConflicts(normalized); System.out.println("resolved = " + resolved); assertEquals(1, resolved.size()); assertSame(normalized.get(0), resolved.get(0)); System.out.println("resolved.get(0).toJson(); = " + resolved.get(0).toJson()); }
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; }
public void checkSampleData(Variant variant, StudyConfiguration studyConfiguration, Integer fileId, Function<Integer, String> valueProvider, String field) { assertTrue(studyConfiguration.getFileIds().values().contains(fileId)); studyConfiguration.getSamplesInFiles().get(fileId).forEach((sampleId) -> { String sampleName = studyConfiguration.getSampleIds().inverse().get(sampleId); StudyEntry study = variant.getStudy(studyConfiguration.getStudyName()); assertTrue(study.getSamplesName().contains(sampleName)); assertEquals("Variant=" + variant + " StudyId=" + studyConfiguration.getStudyId() + " FileId=" + fileId + " Field=" + field + " Sample=" + sampleName + " (" + sampleId + ")\n"+variant.toJson(), valueProvider.apply(sampleId), study.getSampleData(sampleName, field)); }); }
public static void checkCalculatedStats(String studyId, Map<String, Cohort> cohorts, CatalogManager catalogManager, String dbName, String sessionId) throws Exception { VariantDBAdaptor dbAdaptor = StorageEngineFactory.get().getVariantStorageEngine(null, dbName).getDBAdaptor(); for (Variant variant : dbAdaptor) { for (StudyEntry sourceEntry : variant.getStudies()) { assertEquals("In variant " + variant.toString(), cohorts.size(), sourceEntry.getStats().size()); for (Map.Entry<String, VariantStats> entry : sourceEntry.getStats().entrySet()) { assertTrue("In variant " + variant.toString(), cohorts.containsKey(entry.getKey())); if (cohorts.get(entry.getKey()) != null) { assertEquals("Variant: " + variant.toString() + " does not have the correct number of samples in cohort '" + entry.getKey() + "'. jsonVariant: " + variant.toJson() , cohorts.get(entry.getKey()).getSamples().size(), entry.getValue().getGenotypeCount().values().stream().reduce(Integer::sum).orElse(0).intValue()); } } } } for (Cohort cohort : cohorts.values()) { cohort = catalogManager.getCohortManager().get(studyId, cohort.getId(), null, sessionId).first(); assertEquals(Cohort.CohortStatus.READY, cohort.getStatus().getName()); } }
addAttribute(v2, FILTER, "PASS"); System.out.println("v1.toJson() = " + v1.toJson()); System.out.println("v2.toJson() = " + v2.toJson()); System.out.println(); List<Variant> variants = new VariantNormalizer().normalize(Arrays.asList(v1, v2), false); variants.forEach(norm -> System.out.println("norm.toJson() = " + norm.toJson())); System.out.println(); Collection<Variant> resolved = new VariantLocalConflictResolver().resolveConflicts(variants);
@Test public void testIncludeFormat() { Variant variant = query(new Query(INCLUDE_FORMAT.key(), "GT"), new QueryOptions(QueryOptions.LIMIT, 1)).first(); System.out.println("variant.toJson() = " + variant.toJson()); assertEquals("GT", variant.getStudies().get(0).getFormatAsString()); variant = query(new Query(INCLUDE_FORMAT.key(), "GL"), new QueryOptions(QueryOptions.LIMIT, 1)).first(); System.out.println("variant.toJson() = " + variant.toJson()); assertEquals("GL", variant.getStudies().get(0).getFormatAsString()); variant = query(new Query(INCLUDE_FORMAT.key(), "GT,GL,DS"), new QueryOptions(QueryOptions.LIMIT, 1)).first(); System.out.println("variant.toJson() = " + variant.toJson()); assertEquals("GT:GL:DS", variant.getStudies().get(0).getFormatAsString()); variant = query(new Query(INCLUDE_FORMAT.key(), "GT,XX,GL"), new QueryOptions(QueryOptions.LIMIT, 1)).first(); System.out.println("variant.toJson() = " + variant.toJson()); assertEquals("GT:XX:GL", variant.getStudies().get(0).getFormatAsString()); }
@Test public void queryArchiveTable() { final int[] numVariants = {0}; Map<String, Integer> variantCounts = new HashMap<>(); System.out.println("Query from Archive table"); dbAdaptor.iterator( new Query() .append(VariantQueryParam.STUDY.key(), studyConfiguration.getStudyId()) .append(VariantQueryParam.FILE.key(), FILE_ID), new QueryOptions("archive", true)).forEachRemaining(variant -> { System.out.println("Variant from archive = " + variant.toJson()); numVariants[0]++; variantCounts.compute(variant.getType().toString(), (s, integer) -> integer == null ? 1 : (integer + 1)); }); System.out.println("End query from Archive table"); fileMetadata.getStats().getVariantTypeCounts().forEach((s, integer) -> assertEquals(integer, variantCounts.getOrDefault(s, 0))); assertEquals(fileMetadata.getStats().getNumVariants(), numVariants[0]); }
@Test public void bnd() { // INS Variant v = new Variant("1:1000:A:A[3:123["); String id = converter.buildId(v); assertEquals(" 1: 1000:A:A[3_123[::::", id); Variant v2 = converter.buildVariant(id, 999, "A", "A[3:123["); System.out.println("v.toJson() = " + v.toJson()); System.out.println("v2.toJson() = " + v2.toJson()); assertEquals(v, v2); v.getSv().setCiStartLeft(999); v.getSv().setCiStartRight(1010); assertEquals(" 1: 1000:A:A[3_123[:999:1010::", converter.buildId(v)); assertEquals(v, converter.buildVariant(converter.buildId(v), 999, "A", "A[3:123[")); } }
public static Variant asVariant(Variant a, AlternateCoordinate altA) { String chr = ObjectUtils.firstNonNull(altA.getChromosome(), a.getChromosome()); Integer start = ObjectUtils.firstNonNull(altA.getStart(), a.getStart()); Integer end = ObjectUtils.firstNonNull(altA.getEnd(), a.getEnd()); String ref = ObjectUtils.firstNonNull(altA.getReference(), a.getReference()); String alt = ObjectUtils.firstNonNull(altA.getAlternate(), a.getAlternate()); VariantType type = ObjectUtils.firstNonNull(altA.getType(), a.getType()); try { Variant variant = new Variant(chr, start, end, ref, alt); variant.setType(type); return variant; } catch (IllegalArgumentException e) { String msg = altA + "\n" + a.toJson() + "\n"; throw new IllegalStateException(msg, e); } }
@Before public void setUp() throws Exception { clearDB(DB_NAME); VariantStorageEngine variantStorageManager = getVariantStorageEngine(); ObjectMap options = new ObjectMap(VariantStorageEngine.Options.ANNOTATE.key(), false) .append(VariantStorageEngine.Options.CALCULATE_STATS.key(), false) .append(VariantStorageEngine.Options.EXTRA_GENOTYPE_FIELDS.key(), "DP,PS"); runDefaultETL(getResourceUri("variant-test-phased.vcf"), variantStorageManager, newStudyConfiguration(), options); VariantDBAdaptor dbAdaptor = variantStorageManager.getDBAdaptor(); for (Variant variant : dbAdaptor) { System.out.println("variant = " + variant.toJson()); } }