seqair 0.1.0

Pure-Rust BAM/SAM/CRAM/FASTA reader and pileup engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! VCF/BCF error types. Typed fields only, no `String` payloads.

use crate::{io::BgzfError, vcf::writer::WriteError};
use seqair_types::SmolStr;
use std::path::PathBuf;

// r[impl vcf_header.builder]
// r[impl vcf_header.no_duplicates]
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum VcfHeaderError {
    #[error("duplicate contig: {name}")]
    DuplicateContig { name: SmolStr },

    #[error("duplicate INFO field: {id}")]
    DuplicateInfo { id: SmolStr },

    #[error("duplicate FORMAT field: {id}")]
    DuplicateFormat { id: SmolStr },

    #[error("duplicate FILTER: {id}")]
    DuplicateFilter { id: SmolStr },

    #[error("duplicate sample: {name}")]
    DuplicateSample { name: SmolStr },

    #[error("contig not declared in header: {name}")]
    MissingContig { name: SmolStr },

    #[error("INFO field not declared in header: {id}")]
    MissingInfo { id: SmolStr },

    #[error("FORMAT field not declared in header: {id}")]
    MissingFormat { id: SmolStr },

    #[error("FILTER not declared in header: {id}")]
    MissingFilter { id: SmolStr },

    #[error("Flag INFO field {id} must have Number=0")]
    FlagNumberMismatch { id: SmolStr },

    #[error("FORMAT field {id} must not be Flag type")]
    FormatFlagNotAllowed { id: SmolStr },

    // r[impl vcf_record.sample_count]
    #[error("sample count mismatch: header declares {expected}, record has {actual}")]
    SampleCountMismatch { expected: usize, actual: usize },

    // r[impl vcf_record.format_gt_first]
    #[error("GT must be the first FORMAT key, but found at index {index}")]
    GtNotFirst { index: usize },

    #[error("too many contigs (exceeds u32::MAX)")]
    TooManyContigs,

    #[error("too many header fields: BCF string dictionary index exceeds u32::MAX")]
    TooManyFields,
}

// r[impl vcf_record.alleles_typed]
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum AllelesError {
    #[error("SNV alt base must differ from ref")]
    SnvAltEqualsRef,

    #[error("SNV alt bases must not be empty")]
    SnvEmpty,

    #[error("SNV alt bases contain duplicates")]
    SnvDuplicateAlt,

    #[error("insertion sequence must not be empty")]
    InsertionEmpty,

    #[error("deletion sequence must not be empty")]
    DeletionEmpty,
}

#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum VcfEncodeError {
    #[error("value type mismatch for field {field}: expected {expected}, got {got}")]
    TypeMismatch { field: SmolStr, expected: SmolStr, got: SmolStr },

    #[error("integer overflow for field {field}: value {value}")]
    IntegerOverflow { field: SmolStr, value: i64 },
}

#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum VcfError {
    #[error(transparent)]
    Bgzf(#[from] BgzfError),

    #[error(transparent)]
    Header(#[from] VcfHeaderError),

    #[error(transparent)]
    Encode(#[from] VcfEncodeError),

    #[error(transparent)]
    Alleles(#[from] AllelesError),

    #[error(transparent)]
    Io(#[from] std::io::Error),

    #[error(transparent)]
    Index(#[from] crate::io::IndexError),

    #[error("write_header() must be called before write_record()")]
    HeaderNotWritten,

    #[error("FORMAT fields were written but begin_samples() was not called")]
    FormatDataWithoutSamples,

    #[error("FORMAT field has {got} values but header declares {expected} samples")]
    SampleCountMismatch { expected: usize, got: usize },

    #[error(
        "mixed ploidy in GT field: first sample has ploidy {first_ploidy} but sample {mismatch_index} has ploidy {mismatch_ploidy}"
    )]
    MixedPloidy { first_ploidy: usize, mismatch_index: usize, mismatch_ploidy: usize },

    #[error("header text too large for BCF (exceeds u32::MAX)")]
    HeaderTooLarge,

    #[error("BCF record too large: {section} is {size} bytes (exceeds u32::MAX)")]
    RecordTooLarge { section: &'static str, size: usize },

    // r[impl bcf_encoder.checked_casts]
    #[error("value overflow: {field} value {value} exceeds {target_type} range")]
    ValueOverflow { field: &'static str, value: u64, target_type: &'static str },

    // r[impl vcf_writer.output_formats]
    #[error("unrecognized output format for path: {}", path.display())]
    UnrecognizedFormat { path: PathBuf },

    #[error("failed to write float field")]
    FailedToWriteFormattedString { source: WriteError },
}