category iter

src/lib.rs

@@ -11,8 +11,9 @@ mod tests {
     use anyhow::{Ok, Result};
     use indicatif::MultiProgress;
     use indicatif_log_bridge::LogWrapper;
+    use log::info;
 
-    use crate::{config::Config, sql::variants_sql::load_variants_name};
+    use crate::{config::Config, sql::variants_sql::{load_variants_name, remove_variants_names}, variants::{VCFSource, VariantType, Variants, Variant}};
 
     use super::*;
     #[test]
@@ -23,19 +24,159 @@ mod tests {
     }
 
     #[test]
-    fn load_from_db() -> Result<()> {
+    fn load_from_vcf() -> Result<()> {
         let name = "CAMARA";
         let logger =
             env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
                 .build();
         let multi = MultiProgress::new();
+        LogWrapper::new(multi.clone(), logger).try_init().unwrap();
+
+        let cfg = Config::get()?;
+
+        let deepvariant_diag_vcf = format!(
+            "{}/{name}/diag/DeepVariant/{name}_diag_DeepVariant_PASSED.vcf.gz",
+            cfg.longreads_results_dir
+        );
+        if !std::path::Path::new(&deepvariant_diag_vcf).exists() {
+            panic!("{deepvariant_diag_vcf} is required")
+        }
+        let deepvariant_mrd_vcf = format!(
+            "{}/{name}/mrd/DeepVariant/{name}_mrd_DeepVariant_PASSED.vcf.gz",
+            cfg.longreads_results_dir
+        );
+        if !std::path::Path::new(&deepvariant_mrd_vcf).exists() {
+            panic!("{deepvariant_mrd_vcf} is required")
+        }
+        let mrd_bam = format!(
+            "{}/{name}/mrd/{name}_mrd_hs1.bam",
+            cfg.longreads_results_dir
+        );
+        if !std::path::Path::new(&mrd_bam).exists() {
+            panic!("{mrd_bam} is required")
+        }
+        let clairs_vcf = format!(
+            "{}/{name}/diag/ClairS/{name}_diag_clairs_PASSED.vcf.gz",
+            cfg.longreads_results_dir
+        );
+        if !std::path::Path::new(&clairs_vcf).exists() {
+            panic!("{clairs_vcf} is required")
+        }
+        let clairs_indels_vcf = format!(
+            "{}/{name}/diag/ClairS/{name}_diag_clairs_indel_PASSED.vcf.gz",
+            cfg.longreads_results_dir
+        );
+        if !std::path::Path::new(&clairs_indels_vcf).exists() {
+            panic!("{clairs_indels_vcf} is required")
+        }
+        let sniffles_vcf = format!(
+            "{}/{name}/diag/Sniffles/{name}_diag_sniffles.vcf",
+            cfg.longreads_results_dir
+        );
+        let sniffles_mrd_vcf = format!(
+            "{}/{name}/mrd/Sniffles/{name}_mrd_sniffles.vcf",
+            cfg.longreads_results_dir
+        );
+        if !std::path::Path::new(&sniffles_vcf).exists() {
+            panic!("{sniffles_vcf} is required")
+        }
+        let nanomonsv_vcf = format!(
+            "{}/{name}/diag/nanomonsv/{name}_diag_nanomonsv_PASSED.vcf.gz",
+            cfg.longreads_results_dir
+        );
+        if !std::path::Path::new(&nanomonsv_vcf).exists() {
+            panic!("{nanomonsv_vcf} is required")
+        }
+
+        let db_path = "/data/db_results.sqlite".to_string();
+        let loh_path = format!(
+            "{}/{name}/diag/{name}_loh.vcf.gz",
+            cfg.longreads_results_dir
+        );
+
+        let sources = vec![
+            (
+                deepvariant_diag_vcf.as_str(),
+                &VCFSource::DeepVariant,
+                &VariantType::Somatic,
+            ),
+            (
+                deepvariant_mrd_vcf.as_str(),
+                &VCFSource::DeepVariant,
+                &VariantType::Constitutionnal,
+            ),
+            (
+                clairs_vcf.as_str(),
+                &VCFSource::ClairS,
+                &VariantType::Somatic,
+            ),
+            (
+                sniffles_vcf.as_str(),
+                &VCFSource::Sniffles,
+                &VariantType::Somatic,
+            ),
+            (
+                sniffles_mrd_vcf.as_str(),
+                &VCFSource::Sniffles,
+                &VariantType::Constitutionnal,
+            ),
+            (
+                nanomonsv_vcf.as_str(),
+                &VCFSource::Nanomonsv,
+                &VariantType::Somatic,
+            ),
+        ];
+        let mut variants = Variants::from_vcfs(name.to_string(), sources, &cfg, multi.clone())?;
+
+        variants.vcf_filters();
+        variants.write_vcf_cat(&loh_path, &variants::VariantCategory::LOH)?;
+        variants.bam_filters(&mrd_bam);
+        variants.keep_somatics_un();
+        info!("Variants retained: {}", variants.len());
+
+        variants.merge();
+        variants.sort()?;
+        variants.vep();
+        info!("Variants retained: {}", variants.len());
+
+        let gff_path = "/data/ref/hs1/features_not_in_vep.gff.gz";
+        variants.annotate_gff_feature(gff_path)?;
+        variants.echtvar_annotate(&deepvariant_mrd_vcf)?;
+
+        info!("{:?}", variants.data.get(10));
+        variants.filter_snp()?;
+        variants.stats()?;
+
+        if std::path::Path::new(&db_path).exists() {
+            remove_variants_names(&db_path, &name)?;
+        }
+
+        variants.save_sql(&db_path)?;
+        variants.stats_sql(&db_path)?;
+        info!("Variants : {}", variants.len());
+
+        Ok(())
+    }
 
+    #[test]
+    fn load_from_db() -> Result<()> {
+        let name = "CAMARA";
+        let logger =
+            env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
+                .build();
+        let multi = MultiProgress::new();
         LogWrapper::new(multi.clone(), logger).try_init().unwrap();
+
         let mut variants = load_variants_name(name, &multi)?;
+        let v = variants.get_cat(&variants::VariantCategory::Constit);
+        let v = v.iter().filter(|v| 0.25 < v.vaf.unwrap() && v.vaf.unwrap() < 0.75 ).map(|v| {
+
+        }).collect::<Vec<Variant>>();
+
+        lev 
+
         variants.write_vcf_cat("test.vcf.gz", &variants::VariantCategory::Somatic)?;
         println!("{} variants loaded from db.", variants.len());
         Ok(())
     }
-
-
 }

src/variants.rs

@@ -426,7 +426,7 @@ impl Variants {
         pg.finish();
         info!("{}. Executed in {}s", self.stats_vcf, elapsed.as_secs());
     }
-    pub fn get_cat(&mut self, cat: &VariantCategory) -> Vec<Variant> {
+    pub fn get_cat(&mut self, cat: VariantCategory) -> Vec<Variant> {
         let pg = self.mp.add(new_pg_speed(self.data.len() as u64));
         pg.set_message(format!("Get cat {:?}", cat));
         self.data