@Override public String toString() { return variant.toString(); }
public static byte[] toPendingColumn(Variant variant, String gt) { return Bytes.toBytes(PENDING_VARIANT_PREFIX + variant.toString() + '_' + gt); }
private boolean alreadyLoaded(Variant v) { return LOADED_VARIANTS_SET.put(v.toString(), "") != null; }
@Override public boolean write(Variant elem) { try { printer.append(elem.toString()).append("\n"); } catch (IOException e) { return false; } return true; }
@Override public boolean write(List<Variant> batch) { try { for (Variant record : batch) { printer.append(record.toString()).append("\n"); } } catch (IOException e) { return false; } return true; }
@Override public boolean write(Variant variant) { try { variantsGenerator.writeObject(variant); variantsGenerator.writeRaw('\n'); } catch (IOException ex) { logger.error(variant.toString(), ex); close(); throw new UncheckedIOException(ex); } return true; }
default List<QueryResult<Score>> getFunctionalScoreVariant(List<Variant> variants, QueryOptions options) { List<QueryResult<Score>> queryResults = new ArrayList<>(variants.size()); for (Variant variant: variants) { if (variant.getType() == VariantType.SNV) { queryResults.add(getFunctionalScoreVariant(variant, options)); } else { queryResults.add(new QueryResult<>(variant.toString(), 0, 0, 0, null, null, Collections.emptyList())); } } return queryResults; }
default List<QueryResult<Score>> getFunctionalScoreVariant(List<Variant> variants, QueryOptions options) { List<QueryResult<Score>> queryResults = new ArrayList<>(variants.size()); for (Variant variant: variants) { if (variant.getType() == VariantType.SNV) { queryResults.add(getFunctionalScoreVariant(variant, options)); } else { queryResults.add(new QueryResult<>(variant.toString(), 0, 0, 0, null, null, Collections.emptyList())); } } return queryResults; }
protected Variant normalize(Variant variant, boolean normalize) { Variant normalizedVariant; // Convert VCF-style variant to HGVS-style. if (normalize) { List<Variant> normalizedVariantList = NORMALIZER.apply(Collections.singletonList(variant)); if (normalizedVariantList != null && !normalizedVariantList.isEmpty()) { normalizedVariant = normalizedVariantList.get(0); } else { throw new UnsupportedURLVariantFormat("Variant " + variant.toString() + " cannot be properly normalized. " + " Please check."); } } else { normalizedVariant = variant; } return normalizedVariant; }
private List<Variant> normalizeAndAnnotate(List<Variant> variantList) throws InterruptedException, ExecutionException { List<Variant> normalizedVariantList; if (normalize) { normalizedVariantList = new ArrayList<>(variantList.size()); for (Variant variant : variantList) { try { normalizedVariantList.addAll(normalizer.apply(Collections.singletonList(variant))); } catch (RuntimeException e) { logger.warn("Error found during variant normalization. Variant: {}", variant.toString()); logger.warn("This variant will be skipped and annotation will continue"); logger.warn("Full stack trace", e); } } } else { normalizedVariantList = variantList; } for (VariantAnnotator variantAnnotator : variantAnnotatorList) { variantAnnotator.run(normalizedVariantList); } return normalizedVariantList; }
protected Variant normalize(Variant variant, boolean normalize) { Variant normalizedVariant; // Convert VCF-style variant to HGVS-style. if (normalize) { List<Variant> normalizedVariantList = NORMALIZER.apply(Collections.singletonList(variant)); if (normalizedVariantList != null && !normalizedVariantList.isEmpty()) { normalizedVariant = normalizedVariantList.get(0); } else { throw new UnsupportedURLVariantFormat("Variant " + variant.toString() + " cannot be properly normalized. " + " Please check."); } } else { normalizedVariant = variant; } return normalizedVariant; }
public boolean assertWithConflicts(Variant variant, Runnable assertCondition) { try { assertCondition.run(); } catch (AssertionError e) { if (VARIANTS_WITH_CONFLICTS.contains(variant.toString())) { logger.error(e.getMessage()); return false; } else { throw e; } } return true; }
protected Variant convert(Variant variant, Map<Integer, StudyEntry> studies, VariantAnnotation annotation) { for (StudyEntry studyEntry : studies.values()) { variant.addStudyEntry(studyEntry); } variant.setAnnotation(annotation); if (annotation != null && StringUtils.isNotEmpty(annotation.getId())) { variant.setId(annotation.getId()); } else { variant.setId(variant.toString()); } if (failOnEmptyVariants && variant.getStudies().isEmpty()) { throw new IllegalStateException("No Studies registered for variant!!! " + variant); } return variant; }
public VariantQueryResult<Variant> getPhased(Variant variant, String study, String sample, String sessionId, QueryOptions options) throws CatalogException, IOException, StorageEngineException { return secure(new Query(VariantQueryParam.STUDY.key(), study), options, sessionId, engine -> engine.getPhased(variant.toString(), study, sample, options, 5000)); }
protected void checkFillGaps(StudyConfiguration studyConfiguration, VariantHadoopDBAdaptor dbAdaptor, List<Integer> sampleIds, Set<String> variantsWithGaps) { for (Variant variant : dbAdaptor) { boolean anyUnknown = false; boolean allUnknown = true; for (Integer sampleId : sampleIds) { boolean unknown = variant.getStudies().get(0).getSampleData(studyConfiguration.getSampleIds().inverse().get(sampleId), "GT").equals("?/?"); anyUnknown |= unknown; allUnknown &= unknown; } // Fail if any, but not all samples are unknown if (anyUnknown && !allUnknown) { if (variantsWithGaps.contains(variant.toString())) { System.out.println("Gaps in variant " + variant); } else { Assert.fail("Gaps in variant " + variant); } } } }
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; }
@Test public void checkAllAnnotated() throws Exception { for (Variant variant : variantStorageEngine.getDBAdaptor()) { assertNotNull(variant.toString(), variant.getAnnotation()); } }
@Test public void resolveSameVariantWithSecAltInsertion() throws Exception { Variant a = getVariant("2:10048155:-:AT", "PASS", "220", "1/2"); Variant b = getVariant("2:10048155:ATATATATATAT:-", "PASS", "220", "2/1"); a.getStudies().get(0).getSecondaryAlternates().add(new AlternateCoordinate("2", b.getStart(), b.getEnd(), b.getReference(), b.getAlternate(), INDEL)); b.getStudies().get(0).getSecondaryAlternates().add(new AlternateCoordinate("2", a.getStart(), a.getEnd(), a.getReference(), a.getAlternate(), INDEL)); List<Variant> resolved = new ArrayList<>(new VariantLocalConflictResolver().resolveConflicts(Arrays.asList(a, b))); System.out.println("a.toString() = " + a.toString()); System.out.println("b.getStudies().get(0).getSecondaryAlternates().get(0).toString() = " + b.getStudies().get(0).getSecondaryAlternates().get(0).toString()); assertEquals(1, resolved.size()); assertEquals(1, resolved.get(0).getStudies().get(0).getSecondaryAlternates().size()); assertEquals("1/2", resolved.get(0).getStudies().get(0).getSamplesData().get(0).get(0)); }
public void checkVariantRowKeyGeneration(Variant variant) { byte[] phoenixRowKey = generateVariantRowKeyPhoenix(variant); // System.out.println("expected = " + Bytes.toStringBinary(phoenixRowKey)); byte[] variantRowkey = VariantPhoenixKeyFactory.generateVariantRowKey(variant); // System.out.println("actual = " + Bytes.toStringBinary(variantRowkey)); Variant generatedVariant = VariantPhoenixKeyFactory.extractVariantFromVariantRowKey(variantRowkey); assertArrayEquals(variant.toString(), phoenixRowKey, variantRowkey); assertEquals(variant, generatedVariant); }
@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); } }