1use std::collections::HashSet;
2use std::fs::File;
3use std::io::{self, BufWriter, Read, Write};
4use std::path::Path;
5
6use noodles::{
7 bcf, bgzf,
8 core::{Position, Region},
9 vcf,
10 vcf::variant::{Record as _, io::Write as _},
11};
12use noodles_util::variant;
13
14use crate::{CallError, CalledSite, CalledVcfSchema, LikelihoodSite, LikelihoodVcfSchema, Result};
15
16#[derive(Clone, Copy, Debug, PartialEq, Eq)]
17pub enum VariantOutputFormat {
18 Vcf,
19 VcfBgzf,
20 BcfRaw,
21 BcfBgzf,
22}
23
24pub struct LikelihoodVariantReader<R>
25where
26 R: Read,
27{
28 inner: variant::io::Reader<R>,
29 projection: LikelihoodProjection,
30 record: variant::Record,
31 record_number: u64,
32 started: bool,
33}
34
35impl<R> LikelihoodVariantReader<R>
36where
37 R: Read,
38{
39 pub fn new(reader: R) -> Result<Self> {
40 let mut inner = variant::io::Reader::new(reader).map_err(input_error)?;
41 let header = inner.read_header().map_err(input_error)?;
42 Ok(Self {
43 inner,
44 projection: LikelihoodProjection::new(header)?,
45 record: variant::Record::default(),
46 record_number: 0,
47 started: false,
48 })
49 }
50
51 pub fn schema(&self) -> &LikelihoodVcfSchema {
52 self.projection.schema()
53 }
54
55 pub fn record_number(&self) -> u64 {
56 self.record_number
57 }
58
59 pub fn select_samples(
60 mut self,
61 samples: impl IntoIterator<Item = impl AsRef<str>>,
62 ) -> Result<Self> {
63 self.require_unread()?;
64 self.projection.select_samples(samples)?;
65 Ok(self)
66 }
67
68 pub fn exclude_samples(
69 mut self,
70 samples: impl IntoIterator<Item = impl AsRef<str>>,
71 ) -> Result<Self> {
72 self.require_unread()?;
73 self.projection.exclude_samples(samples)?;
74 Ok(self)
75 }
76
77 pub fn with_prior_frequencies(
78 mut self,
79 total_alleles_tag: impl Into<String>,
80 alternate_counts_tag: impl Into<String>,
81 ) -> Result<Self> {
82 self.require_unread()?;
83 self.projection
84 .set_prior_frequency_tags(total_alleles_tag, alternate_counts_tag)?;
85 Ok(self)
86 }
87
88 pub fn read_site(&mut self) -> Result<Option<LikelihoodSite>> {
89 self.started = true;
90 let record_number = self.record_number + 1;
91 let size = self
92 .inner
93 .read_record(&mut self.record)
94 .map_err(|error| record_error(record_number, error))?;
95 if size == 0 {
96 return Ok(None);
97 }
98 self.record_number = record_number;
99 let record = vcf::variant::RecordBuf::try_from_variant_record(
100 self.projection.input_header(),
101 &self.record,
102 )
103 .map_err(|error| record_error(record_number, error))?;
104 self.projection
105 .decode(&record)
106 .map_err(|error| CallError::LikelihoodVariantRecord {
107 record: record_number,
108 message: error.to_string(),
109 })
110 .map(Some)
111 }
112
113 fn require_unread(&self) -> Result<()> {
114 if self.started {
115 return Err(CallError::LateLikelihoodReaderConfiguration);
116 }
117 Ok(())
118 }
119}
120
121pub struct IndexedLikelihoodVariantReader {
122 inner: variant::io::indexed_reader::IndexedReader<bgzf::io::Reader<File>>,
123 projection: LikelihoodProjection,
124}
125
126impl IndexedLikelihoodVariantReader {
127 pub fn open(path: impl AsRef<Path>) -> Result<Self> {
128 let path = path.as_ref();
129 let mut inner = variant::io::indexed_reader::Builder::default()
130 .build_from_path(path)
131 .map_err(|error| path_input_error(path, error))?;
132 let header = inner
133 .read_header()
134 .map_err(|error| path_input_error(path, error))?;
135 Ok(Self {
136 inner,
137 projection: LikelihoodProjection::new(header)?,
138 })
139 }
140
141 pub fn schema(&self) -> &LikelihoodVcfSchema {
142 self.projection.schema()
143 }
144
145 pub fn select_samples(
146 mut self,
147 samples: impl IntoIterator<Item = impl AsRef<str>>,
148 ) -> Result<Self> {
149 self.projection.select_samples(samples)?;
150 Ok(self)
151 }
152
153 pub fn exclude_samples(
154 mut self,
155 samples: impl IntoIterator<Item = impl AsRef<str>>,
156 ) -> Result<Self> {
157 self.projection.exclude_samples(samples)?;
158 Ok(self)
159 }
160
161 pub fn with_prior_frequencies(
162 mut self,
163 total_alleles_tag: impl Into<String>,
164 alternate_counts_tag: impl Into<String>,
165 ) -> Result<Self> {
166 self.projection
167 .set_prior_frequency_tags(total_alleles_tag, alternate_counts_tag)?;
168 Ok(self)
169 }
170
171 pub(crate) fn normalize_regions(
172 &self,
173 regions: impl IntoIterator<Item = Region>,
174 ) -> Result<PreparedVariantRegions> {
175 normalize_variant_regions(self.projection.input_header(), regions)
176 }
177
178 pub(crate) fn normalize_region_file(
179 &self,
180 regions: impl IntoIterator<Item = Region>,
181 ) -> Result<PreparedVariantRegions> {
182 normalize_variant_region_file(self.projection.input_header(), regions)
183 }
184
185 pub(crate) fn visit_normalized_regions(
186 mut self,
187 regions: PreparedVariantRegions,
188 mut visit: impl FnMut(u64, LikelihoodSite) -> Result<()>,
189 ) -> Result<()> {
190 let header = self.projection.input_header();
191 let mut record_number = 0;
192
193 for (region_index, region) in regions.values.iter().enumerate() {
194 let records = self
195 .inner
196 .query(header, ®ion.query)
197 .map_err(|error| query_error(®ion.query, error))?;
198 for result in records {
199 record_number += 1;
200 let record = result.map_err(|error| record_error(record_number, error))?;
201 let record =
202 vcf::variant::RecordBuf::try_from_variant_record(header, record.as_ref())
203 .map_err(|error| record_error(record_number, error))?;
204 let start = record.variant_start().ok_or_else(|| {
205 record_error(
206 record_number,
207 io::Error::new(io::ErrorKind::InvalidData, "missing variant position"),
208 )
209 })?;
210 let end = record
211 .variant_end(header)
212 .map_err(|error| record_error(record_number, error))?;
213 if regions.deduplicate
214 && regions.values[..region_index]
215 .iter()
216 .any(|previous| previous.overlaps(region.reference_id, start, end))
217 {
218 continue;
219 }
220 let site = self.projection.decode(&record).map_err(|error| {
221 CallError::LikelihoodVariantRecord {
222 record: record_number,
223 message: error.to_string(),
224 }
225 })?;
226 visit(record_number, site)?;
227 }
228 }
229 Ok(())
230 }
231}
232
233pub(crate) struct VariantRegion {
234 query: Region,
235 reference_id: usize,
236 start: Position,
237 end: Position,
238}
239
240pub(crate) struct PreparedVariantRegions {
241 values: Vec<VariantRegion>,
242 deduplicate: bool,
243}
244
245impl VariantRegion {
246 fn overlaps(&self, reference_id: usize, start: Position, end: Position) -> bool {
247 self.reference_id == reference_id && start <= self.end && end >= self.start
248 }
249}
250
251fn normalize_variant_regions(
252 header: &vcf::Header,
253 regions: impl IntoIterator<Item = Region>,
254) -> Result<PreparedVariantRegions> {
255 let mut values = resolve_variant_regions(header, regions)?;
256 values.sort_unstable_by_key(|region| (region.reference_id, region.start, region.end));
257
258 let mut merged: Vec<VariantRegion> = Vec::with_capacity(values.len());
259 for region in values {
260 if let Some(previous) = merged.last_mut()
261 && previous.reference_id == region.reference_id
262 && region.start <= previous.end.checked_add(1).unwrap_or(Position::MAX)
263 {
264 previous.end = previous.end.max(region.end);
265 previous.query = Region::new(
266 previous.query.name().to_vec(),
267 previous.start..=previous.end,
268 );
269 } else {
270 merged.push(region);
271 }
272 }
273 Ok(PreparedVariantRegions {
274 values: merged,
275 deduplicate: true,
276 })
277}
278
279fn normalize_variant_region_file(
280 header: &vcf::Header,
281 regions: impl IntoIterator<Item = Region>,
282) -> Result<PreparedVariantRegions> {
283 let mut values = resolve_variant_regions(header, regions)?;
284 let mut ranks = vec![usize::MAX; header.contigs().len()];
285 let mut next_rank = 0;
286 for region in &values {
287 if ranks[region.reference_id] == usize::MAX {
288 ranks[region.reference_id] = next_rank;
289 next_rank += 1;
290 }
291 }
292 values.sort_by_key(|region| (ranks[region.reference_id], region.start, region.end));
293 Ok(PreparedVariantRegions {
294 values,
295 deduplicate: true,
296 })
297}
298
299fn resolve_variant_regions(
300 header: &vcf::Header,
301 regions: impl IntoIterator<Item = Region>,
302) -> Result<Vec<VariantRegion>> {
303 let mut values = Vec::new();
304 for region in regions {
305 let name =
306 std::str::from_utf8(region.name().as_ref()).map_err(|_| CallError::InvalidRegion {
307 region: region.to_string(),
308 message: "reference sequence name is not UTF-8".to_owned(),
309 })?;
310 let (reference_id, _, contig) =
311 header
312 .contigs()
313 .get_full(name)
314 .ok_or_else(|| CallError::InvalidRegion {
315 region: region.to_string(),
316 message: "reference sequence is absent from the variant header".to_owned(),
317 })?;
318 let start = region.interval().start().unwrap_or(Position::MIN);
319 let end = match contig.length().and_then(Position::new) {
320 Some(length) if start > length => {
321 return Err(CallError::InvalidRegion {
322 region: region.to_string(),
323 message: "interval is outside the reference sequence".to_owned(),
324 });
325 }
326 Some(length) => region.interval().end().unwrap_or(length).min(length),
327 None => region.interval().end().unwrap_or(Position::MAX),
328 };
329 values.push(VariantRegion {
330 query: Region::new(name, start..=end),
331 reference_id,
332 start,
333 end,
334 });
335 }
336 if values.is_empty() {
337 return Err(CallError::MissingRegions);
338 }
339 Ok(values)
340}
341
342pub(crate) struct LikelihoodProjection {
343 input_schema: LikelihoodVcfSchema,
344 schema: LikelihoodVcfSchema,
345 sample_indices: Box<[usize]>,
346}
347
348impl LikelihoodProjection {
349 pub(crate) fn new(header: vcf::Header) -> Result<Self> {
350 let schema = LikelihoodVcfSchema::from_header(header)?;
351 let sample_indices = (0..schema.header().sample_names().len()).collect();
352 Ok(Self {
353 input_schema: schema.clone(),
354 schema,
355 sample_indices,
356 })
357 }
358
359 pub(crate) fn schema(&self) -> &LikelihoodVcfSchema {
360 &self.schema
361 }
362
363 pub(crate) fn input_header(&self) -> &vcf::Header {
364 self.input_schema.header()
365 }
366
367 pub(crate) fn select_samples(
368 &mut self,
369 samples: impl IntoIterator<Item = impl AsRef<str>>,
370 ) -> Result<()> {
371 let mut seen = HashSet::new();
372 let mut indices = Vec::new();
373 for sample in samples {
374 let sample = sample.as_ref();
375 if !seen.insert(sample.to_owned()) {
376 return Err(CallError::DuplicateSampleSelection(sample.to_owned()));
377 }
378 let index = self
379 .input_schema
380 .header()
381 .sample_names()
382 .get_index_of(sample)
383 .ok_or_else(|| CallError::MissingSelectedSample(sample.to_owned()))?;
384 indices.push(index);
385 }
386 self.set_sample_indices(indices)
387 }
388
389 pub(crate) fn exclude_samples(
390 &mut self,
391 samples: impl IntoIterator<Item = impl AsRef<str>>,
392 ) -> Result<()> {
393 let mut excluded = HashSet::new();
394 for sample in samples {
395 let sample = sample.as_ref();
396 if !excluded.insert(sample.to_owned()) {
397 return Err(CallError::DuplicateSampleSelection(sample.to_owned()));
398 }
399 if !self.input_schema.header().sample_names().contains(sample) {
400 return Err(CallError::MissingSelectedSample(sample.to_owned()));
401 }
402 }
403 let indices = self
404 .input_schema
405 .header()
406 .sample_names()
407 .iter()
408 .enumerate()
409 .filter_map(|(index, sample)| (!excluded.contains(sample)).then_some(index))
410 .collect();
411 self.set_sample_indices(indices)
412 }
413
414 pub(crate) fn decode(&self, record: &vcf::variant::RecordBuf) -> Result<LikelihoodSite> {
415 self.input_schema
416 .decode_selected_likelihood(record, &self.sample_indices)
417 }
418
419 pub(crate) fn set_prior_frequency_tags(
420 &mut self,
421 total: impl Into<String>,
422 alternates: impl Into<String>,
423 ) -> Result<()> {
424 let total = total.into();
425 let alternates = alternates.into();
426 self.input_schema
427 .set_prior_frequency_tags(total.clone(), alternates.clone())?;
428 self.schema.set_prior_frequency_tags(total, alternates)
429 }
430
431 fn set_sample_indices(&mut self, indices: Vec<usize>) -> Result<()> {
432 if indices.is_empty() {
433 return Err(CallError::InvalidSampleCount);
434 }
435 let mut header = self.input_schema.header().clone();
436 header.sample_names_mut().clear();
437 for &index in &indices {
438 header
439 .sample_names_mut()
440 .insert(self.input_schema.header().sample_names()[index].clone());
441 }
442 let prior_frequency_tags = self
443 .schema
444 .prior_frequency_tags()
445 .map(|(total, alternates)| (total.to_owned(), alternates.to_owned()));
446 self.schema = LikelihoodVcfSchema::from_header(header)?;
447 if let Some((total, alternates)) = prior_frequency_tags {
448 self.schema.set_prior_frequency_tags(total, alternates)?;
449 }
450 self.sample_indices = indices.into_boxed_slice();
451 Ok(())
452 }
453}
454
455pub struct LikelihoodVariantWriter<W>
456where
457 W: Write,
458{
459 inner: VariantWriter<W>,
460 schema: LikelihoodVcfSchema,
461}
462
463impl<W> LikelihoodVariantWriter<W>
464where
465 W: Write,
466{
467 pub fn new(
468 writer: W,
469 schema: LikelihoodVcfSchema,
470 format: VariantOutputFormat,
471 ) -> Result<Self> {
472 let mut inner = VariantWriter::new(writer, format);
473 inner.write_header(schema.header())?;
474 Ok(Self { inner, schema })
475 }
476
477 pub fn schema(&self) -> &LikelihoodVcfSchema {
478 &self.schema
479 }
480
481 pub fn write_site(&mut self, site: &LikelihoodSite) -> Result<()> {
482 let record = self.schema.encode_likelihood(site)?;
483 self.inner.write_record(self.schema.header(), &record)
484 }
485
486 pub fn finish(self) -> Result<W> {
487 self.inner.finish()
488 }
489}
490
491pub struct CalledVariantWriter<W>
492where
493 W: Write,
494{
495 inner: VariantWriter<W>,
496 schema: CalledVcfSchema,
497}
498
499impl<W> CalledVariantWriter<W>
500where
501 W: Write,
502{
503 pub fn new(writer: W, schema: CalledVcfSchema, format: VariantOutputFormat) -> Result<Self> {
504 let mut inner = VariantWriter::new(writer, format);
505 inner.write_header(schema.header())?;
506 Ok(Self { inner, schema })
507 }
508
509 pub fn schema(&self) -> &CalledVcfSchema {
510 &self.schema
511 }
512
513 pub fn write_site(&mut self, site: &CalledSite) -> Result<()> {
514 let record = self.schema.encode_call(site)?;
515 self.inner.write_record(self.schema.header(), &record)
516 }
517
518 pub fn finish(self) -> Result<W> {
519 self.inner.finish()
520 }
521}
522
523enum VariantWriter<W>
524where
525 W: Write,
526{
527 Vcf(vcf::io::Writer<BufWriter<W>>),
528 VcfBgzf(vcf::io::Writer<bgzf::io::Writer<W>>),
529 BcfRaw(bcf::io::Writer<BufWriter<W>>),
530 BcfBgzf(bcf::io::Writer<bgzf::io::Writer<W>>),
531}
532
533impl<W> VariantWriter<W>
534where
535 W: Write,
536{
537 fn new(writer: W, format: VariantOutputFormat) -> Self {
538 match format {
539 VariantOutputFormat::Vcf => Self::Vcf(vcf::io::Writer::new(BufWriter::new(writer))),
540 VariantOutputFormat::VcfBgzf => {
541 Self::VcfBgzf(vcf::io::Writer::new(bgzf::io::Writer::new(writer)))
542 }
543 VariantOutputFormat::BcfRaw => {
544 Self::BcfRaw(bcf::io::Writer::from(BufWriter::new(writer)))
545 }
546 VariantOutputFormat::BcfBgzf => Self::BcfBgzf(bcf::io::Writer::new(writer)),
547 }
548 }
549
550 fn write_header(&mut self, header: &vcf::Header) -> Result<()> {
551 match self {
552 Self::Vcf(writer) => writer.write_header(header),
553 Self::VcfBgzf(writer) => writer.write_header(header),
554 Self::BcfRaw(writer) => writer.write_header(header),
555 Self::BcfBgzf(writer) => writer.write_header(header),
556 }
557 .map_err(output_error)
558 }
559
560 fn write_record(
561 &mut self,
562 header: &vcf::Header,
563 record: &dyn vcf::variant::Record,
564 ) -> Result<()> {
565 match self {
566 Self::Vcf(writer) => writer.write_variant_record(header, record),
567 Self::VcfBgzf(writer) => writer.write_variant_record(header, record),
568 Self::BcfRaw(writer) => writer.write_variant_record(header, record),
569 Self::BcfBgzf(writer) => writer.write_variant_record(header, record),
570 }
571 .map_err(output_error)
572 }
573
574 fn finish(self) -> Result<W> {
575 match self {
576 Self::Vcf(writer) => finish_buffer(writer.into_inner()),
577 Self::VcfBgzf(writer) => writer.into_inner().finish().map_err(output_error),
578 Self::BcfRaw(writer) => finish_buffer(writer.into_inner()),
579 Self::BcfBgzf(writer) => writer.into_inner().finish().map_err(output_error),
580 }
581 }
582}
583
584fn finish_buffer<W>(writer: BufWriter<W>) -> Result<W>
585where
586 W: Write,
587{
588 writer
589 .into_inner()
590 .map_err(|error| output_error(error.into_error()))
591}
592
593fn input_error(error: io::Error) -> CallError {
594 CallError::LikelihoodVariantInput(error.to_string())
595}
596
597fn path_input_error(path: &Path, error: io::Error) -> CallError {
598 CallError::LikelihoodVariantInput(format!("{}: {error}", path.display()))
599}
600
601fn query_error(region: &Region, error: io::Error) -> CallError {
602 CallError::LikelihoodVariantInput(format!("querying region {region}: {error}"))
603}
604
605fn record_error(record: u64, error: io::Error) -> CallError {
606 CallError::LikelihoodVariantRecord {
607 record,
608 message: error.to_string(),
609 }
610}
611
612fn output_error(error: io::Error) -> CallError {
613 CallError::VariantOutput(error.to_string())
614}
615
616#[cfg(test)]
617mod tests;