blobtk 0.8.1

Core utilities for BlobToolKit.
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

use std::collections::HashMap;
use std::collections::HashSet;
use std::path::PathBuf;

use crate::bam::{self, BinnedCov};
use crate::cli::DepthOptions;
use crate::io;
use crate::python::utils::{extract_to_option_list, extract_to_option_pathbuf, extract_to_usize};
use pyo3::prelude::*;

#[pymethods]
impl DepthOptions {
    #[new]
    fn new(
        bin_size: usize,
        list: Option<HashSet<Vec<u8>>>,
        list_file: Option<PathBuf>,
        bam: Option<PathBuf>,
        cram: Option<PathBuf>,
        fasta: Option<PathBuf>,
        bed: Option<PathBuf>,
    ) -> Self {
        DepthOptions {
            list,
            list_file,
            bam,
            cram,
            fasta,
            bin_size,
            bed,
        }
    }
}

#[pyfunction]
pub fn bam_to_bed_with_options(options: &DepthOptions, py: Python) -> PyResult<usize> {
    let seq_names = match options.list.to_owned() {
        Some(value) => value,
        _ => {
            let value = options.list_file.to_owned();
            io::get_list(&value)
        }
    };
    let ctrlc_wrapper = || {
        py.check_signals().unwrap();
    };
    let bam = bam::open_bam(&options.bam, &options.cram, &options.fasta, true);
    bam::get_bed_file(bam, &seq_names, options, &Some(Box::new(ctrlc_wrapper)));
    Ok(1)
}

#[pyfunction]
pub fn bam_to_depth_with_options(options: &DepthOptions, py: Python) -> Vec<BinnedCov> {
    let seq_names = match options.list.to_owned() {
        Some(value) => value,
        _ => {
            let value = options.list_file.to_owned();
            io::get_list(&value)
        }
    };
    let ctrlc_wrapper = || {
        py.check_signals().unwrap();
    };
    let bam = bam::open_bam(&options.bam, &options.cram, &options.fasta, true);
    bam::get_depth(bam, &seq_names, options, &Some(Box::new(ctrlc_wrapper)))
}

fn convert_hashmap_to_options(py: Python<'_>, map: HashMap<String, PyObject>) -> DepthOptions {
    let list = extract_to_option_list(py, &map, "list");
    let list_file = extract_to_option_pathbuf(py, &map, "list_file");
    let bam = extract_to_option_pathbuf(py, &map, "bam");
    let cram = extract_to_option_pathbuf(py, &map, "cram");
    let fasta = extract_to_option_pathbuf(py, &map, "fasta");
    let bed = extract_to_option_pathbuf(py, &map, "bed");
    let bin_size = extract_to_usize(py, &map, "bin_size");
    DepthOptions {
        bin_size,
        list,
        list_file,
        bam,
        cram,
        fasta,
        bed,
    }
}

#[pyfunction]
#[pyo3(signature = (**kwds))]
pub fn bam_to_bed(py: Python<'_>, kwds: Option<HashMap<String, PyObject>>) -> PyResult<()> {
    let options = match kwds {
        Some(map) => convert_hashmap_to_options(py, map),
        None => panic!["No arguments provided"],
    };
    bam_to_bed_with_options(&options, py)?;
    Ok(())
}

#[pyfunction]
#[pyo3(signature = (**kwds))]
pub fn bam_to_depth(py: Python<'_>, kwds: Option<HashMap<String, PyObject>>) -> Vec<BinnedCov> {
    let options = match kwds {
        Some(map) => convert_hashmap_to_options(py, map),
        None => panic!["No arguments provided"],
    };
    bam_to_depth_with_options(&options, py)
}