use sassy::profiles::{Dna, Iupac, Profile};
use sassy::{EncodedPatterns, RcSearchAble, Searcher};
pub type PlainSearcher = Searcher<Dna>;
pub type AmbiguousSearcher = Searcher<Iupac>;
#[derive(Debug, Clone)]
pub struct EncodedAdapterBatch {
forward: EncodedPatterns<Iupac>,
complement: EncodedPatterns<Iupac>,
}
pub const MAX_TILED_PATTERN_LEN: usize = 64;
pub fn is_plain_acgt(seq: &[u8]) -> bool {
seq.iter()
.all(|b| matches!(b, b'A' | b'C' | b'G' | b'T' | b'a' | b'c' | b'g' | b't'))
}
pub fn iupac_bases(code: u8) -> Option<&'static [u8]> {
Some(match code.to_ascii_uppercase() {
b'A' => b"A",
b'C' => b"C",
b'G' => b"G",
b'T' => b"T",
b'R' => b"AG",
b'Y' => b"CT",
b'S' => b"CG",
b'W' => b"AT",
b'K' => b"GT",
b'M' => b"AC",
b'B' => b"CGT",
b'D' => b"AGT",
b'H' => b"ACT",
b'V' => b"ACG",
b'N' => b"ACGT",
_ => return None,
})
}
pub fn iupac_degeneracy(code: u8) -> Option<u8> {
iupac_bases(code).map(|bases| bases.len() as u8)
}
#[derive(Debug, Clone, Copy)]
pub struct Strands<'a> {
pub forward: &'a [u8],
pub reversed: &'a [u8],
}
impl RcSearchAble for Strands<'_> {
fn text(&self) -> impl AsRef<[u8]> {
self.forward
}
fn rev_text(&self) -> impl AsRef<[u8]> {
self.reversed
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Hit {
pub start: usize,
pub end: usize,
pub cost: usize,
pub left_overhang: usize,
pub right_overhang: usize,
pub clip_start: usize,
pub clip_end: usize,
pub rc: bool,
}
impl Hit {
fn from_match(m: &sassy::Match, pattern_len: usize) -> Self {
let (head, tail) = (m.pattern_start, pattern_len - m.pattern_end);
let rc = m.strand == sassy::Strand::Rc;
let (left_overhang, right_overhang) = if rc { (tail, head) } else { (head, tail) };
let (clip_start, clip_end) = super::refine::clips(m, rc);
Hit {
start: m.text_start,
end: m.text_end,
cost: m.cost as usize,
left_overhang,
right_overhang,
clip_start,
clip_end,
rc,
}
}
}
pub fn new_searcher() -> PlainSearcher {
Searcher::<Dna>::new_rc()
}
pub fn new_ambiguous_searcher() -> AmbiguousSearcher {
Searcher::<Iupac>::new_rc()
}
pub fn new_overhang_searcher(alpha: f32) -> AmbiguousSearcher {
Searcher::<Iupac>::new_rc_with_overhang(alpha.clamp(0.0, 1.0))
}
pub fn new_searcher_fwd() -> AmbiguousSearcher {
Searcher::<Iupac>::new_fwd()
}
pub fn encode_patterns(patterns: &[Vec<u8>]) -> EncodedAdapterBatch {
debug_assert!(
patterns
.first()
.is_some_and(|p| (1..=MAX_TILED_PATTERN_LEN).contains(&p.len()))
);
let mut encoder = Searcher::<Iupac>::new_fwd();
let complements: Vec<Vec<u8>> = patterns.iter().map(|p| Iupac::complement(p)).collect();
EncodedAdapterBatch {
forward: encoder.encode_patterns(patterns),
complement: encoder.encode_patterns(&complements),
}
}
pub fn encoded_pattern_hits(
searcher: &mut AmbiguousSearcher,
encoded: &EncodedAdapterBatch,
text: &[u8],
reversed: &[u8],
k: usize,
mut accept: impl FnMut(usize, Hit),
) {
debug_assert_eq!(text.len(), reversed.len());
let whole = |m: &sassy::Match, start: usize, end: usize, (clip_start, clip_end), rc| Hit {
start,
end,
cost: m.cost as usize,
left_overhang: 0,
right_overhang: 0,
clip_start,
clip_end,
rc,
};
for m in searcher.search_encoded_patterns(&encoded.forward, text, k) {
let hit = whole(
m,
m.text_start,
m.text_end,
super::refine::clips(m, false),
false,
);
accept(m.pattern_idx, hit);
}
let n = text.len();
for m in searcher.search_encoded_patterns(&encoded.complement, reversed, k) {
let (on_reversed_start, on_reversed_end) = super::refine::clips(m, false);
let hit = whole(
m,
n - m.text_end,
n - m.text_start,
(on_reversed_end, on_reversed_start),
true,
);
accept(m.pattern_idx, hit);
}
}
pub fn for_each_hit<P: Profile, T: RcSearchAble + ?Sized>(
searcher: &mut Searcher<P>,
pattern: &[u8],
text: &T,
k: usize,
mut accept: impl FnMut(Hit),
) {
for m in searcher.search(pattern, text, k) {
accept(Hit::from_match(&m, pattern.len()));
}
}
pub fn for_each_hit_in_texts<P: Profile, T: RcSearchAble>(
searcher: &mut Searcher<P>,
pattern: &[u8],
texts: &[T],
k: usize,
mut accept: impl FnMut(usize, Hit),
) {
for m in searcher.search_texts(pattern, texts, k) {
accept(m.text_idx, Hit::from_match(&m, pattern.len()));
}
}
pub fn hits<P: Profile>(
searcher: &mut Searcher<P>,
pattern: &[u8],
text: &[u8],
k: usize,
) -> Vec<Hit> {
let mut out = Vec::new();
for_each_hit(searcher, pattern, text, k, |hit| out.push(hit));
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn exact_forward_match() {
let mut s = new_searcher();
let h = hits(&mut s, b"AAAACCCCGGGG", b"TTAAAACCCCGGGGTT", 0);
assert_eq!(h.len(), 1);
assert_eq!((h[0].start, h[0].end, h[0].cost), (2, 14, 0));
}
#[test]
fn finds_reverse_complement() {
let mut s = new_searcher();
let h = hits(&mut s, b"AAAACCCC", b"TTGGGGTTTTAA", 0);
assert_eq!(h.len(), 1);
assert_eq!((h[0].start, h[0].end), (2, 10));
}
#[test]
fn forward_searcher_ignores_reverse_complement() {
let mut s = new_searcher_fwd();
assert_eq!(hits(&mut s, b"AAAACCCC", b"TTGGGGTTTTAA", 0).len(), 0);
assert_eq!(hits(&mut s, b"AAAACCCC", b"TTAAAACCCCTT", 0).len(), 1);
}
#[test]
fn iupac_bases_cover_the_alphabet_and_reject_the_rest() {
for (code, expected) in [
(b'A', &b"A"[..]),
(b'R', b"AG"),
(b'y', b"CT"),
(b'B', b"CGT"),
(b'N', b"ACGT"),
] {
assert_eq!(iupac_bases(code), Some(expected), "Code {}", code as char);
assert_eq!(iupac_degeneracy(code), Some(expected.len() as u8));
}
for code in *b"UX.-0" {
assert_eq!(
iupac_bases(code),
None,
"Code {} is not a nucleotide",
code as char
);
}
}
#[test]
fn tolerates_one_mismatch_within_budget() {
let mut s = new_searcher();
assert_eq!(
hits(&mut s, b"AAAACCCCGGGG", b"TTAAAACACCGGGGTT", 1).len(),
1
);
assert_eq!(
hits(&mut s, b"AAAACCCCGGGG", b"TTAAAACACCGGGGTT", 0).len(),
0
);
}
}