refactoring repo qc

Author: pnrobinson

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ga4ghphetools"
-version = "0.5.2"
+version = "0.5.3"
 edition = "2021"
 keywords = ["GA4GH", "Phenopacket Schema", "Human Phenotype Ontology"]
 description = "Generate GA4GH phenopackets from tabular data"
@@ -36,7 +36,7 @@ rand = "0.9.2"
 regex = "1.12.1"
 serde = { version = "1.0.228", features = ["derive"] }
 zip = "6.0.0"
-reqwest = {version = "0.12.28", features = ["blocking", "json"]}
+reqwest = {version = "0.13.1", features = ["blocking", "json"]}
 serde_json = { version = "1.0.148", features = ["preserve_order"] }
 clap = { version = "4.5.53", features = ["derive"], optional = true }
 rayon = "=1.10.0"

src/repo/cohort_qc.rs

@@ -29,7 +29,7 @@ impl CohortQc {
             } else {
                 // by design, Mendelian can only have one disease
                 let ddata = &cohort.disease_list[0];
-                let dqc = DiseaseQc::new(ddata);
+                let dqc = DiseaseQc::new(ddata, &cohort);
                 disease_to_ppkt_d.insert(ddata.disease_id.clone(), dqc);
             }
         }
@@ -56,6 +56,25 @@ impl CohortQc {
         })
     }
 
+
+    pub fn get_errors(&self) -> Vec<QcReport> {
+        let mut errs: Vec<QcReport> = self
+            .unexpected_files
+            .iter()
+            .map(|file| QcReport::unexpected_file(&self.cohort_name, file))
+            .collect();
+
+        errs.extend(self.check_moi());
+
+        errs.extend(
+            self.disease_qc_list
+                .iter()
+                .filter_map(|dqc| dqc.check_all_rows_output_as_ppkt()),
+        );
+
+        errs
+    }
+
 
     fn get_disease_id(ppkt: &Phenopacket) -> Result<String, String> {
         if ppkt.diseases.len() != 1 {
@@ -67,27 +86,16 @@ impl CohortQc {
         }
     }
 
-    pub fn has_unexpected_files(&self) -> QcReport {
-        if self.unexpected_files.is_empty() {
-            QcReport::no_unepected_files(&self.cohort_name)
-        } else {
-            QcReport::unexpected_files(&self.cohort_name, &self.unexpected_files)
-        }
-    }
+    
 
     pub fn ppkt_count(&self) -> usize {
         return self.disease_qc_list.iter().map(|dqc|dqc.phenopacket_count()).sum();
     }
 
-    pub fn check_moi(&self) -> usize {
-        let mut misfit = 0 as usize;
-        for dqc in &self.disease_qc_list {
-            if let Some(output) = dqc.check_moi() {
-                println!("{}", output);
-                misfit += 1;
-            }
-        }
-        misfit
+    pub fn check_moi(&self) -> Vec<QcReport> {
+        self.disease_qc_list.iter()
+            .flat_map(|dqc|dqc.check_moi())
+            .collect()
     }
 
 

src/repo/disease_qc.rs

@@ -2,22 +2,24 @@ use std::collections::HashSet;
 
 use phenopackets::schema::v2::{Phenopacket, core::genomic_interpretation::Call};
 
-use crate::dto::cohort_dto::{DiseaseData};
+use crate::{dto::cohort_dto::{CohortData, DiseaseData}, repo::qc_report::QcReport};
 
 
 
 #[derive(Clone, Debug)]
 pub struct DiseaseQc {
     disease_data: DiseaseData,
-    ppkt_list: Vec<Phenopacket>
+    ppkt_list: Vec<Phenopacket>,
+    cohort: CohortData,
 }
 
 
 impl DiseaseQc {
-    pub fn new(disease_data: &DiseaseData) -> Self {
+    pub fn new(disease_data: &DiseaseData, cohort: &CohortData) -> Self {
         Self { 
             disease_data: disease_data.clone(), 
-            ppkt_list: Vec::new() 
+            ppkt_list: Vec::new(),
+            cohort: cohort.clone()
         }
     }
 
@@ -30,7 +32,8 @@ impl DiseaseQc {
         return self.ppkt_list.len();
     }
 
-    pub fn check_moi(&self) -> Option<String> {
+    pub fn check_moi(&self) -> Vec<QcReport> {
+        let mut errs: Vec<QcReport> = Vec::new();
         let mut allowable_allele_counts: HashSet<usize> = HashSet::new();
         for moi in &self.disease_data.mode_of_inheritance_list {
             if moi.is_autosomal_dominant() {
@@ -40,16 +43,17 @@ impl DiseaseQc {
             } else if moi.is_x_chromosomal() {
                 allowable_allele_counts.insert(1);
             } else {
-                return Some(format!("Did not recognize MOI: {:?}", moi));
+                eprintln!("Did not recognize MOI: {:?}", moi);
             }
         }
         for ppkt in &self.ppkt_list {
             let ac = Self::get_allele_count(ppkt);
             if ! allowable_allele_counts.contains(&ac) {
-                return Some(format!("{}: Expected counts of {:?} but got {} for {}.", ppkt.id,allowable_allele_counts, ac, self.disease_data_display()))
+                let qc = QcReport::moi_mismatch(&self.disease_data_display(), &ppkt.id, &allowable_allele_counts, ac);
+                errs.push(qc);
             }
         }
-        None
+        errs
     }
 
     fn disease_data_display(&self) -> String {
@@ -87,4 +91,15 @@ impl DiseaseQc {
 
         ac
     }
+
+    pub fn check_all_rows_output_as_ppkt(&self) -> Option<QcReport> {
+        let n_nrows = self.cohort.rows.len();
+        let n_phenopackets = self.phenopacket_count();
+        if n_nrows == n_phenopackets {
+            return None;
+        } else {
+            return Some(QcReport::count_mismatch(&self.disease_data_display(), n_nrows, n_phenopackets))
+        }
+    }
+
 }

src/repo/gpt_repository.rs

@@ -43,7 +43,7 @@ impl GptRepository {
             .map(|cl| cl.get_cohort_qc())
             .collect();
         match result {
-            Ok(cohort_qc_list) => Ok(RepoQc::new(cohort_qc_list)),
+            Ok(cohort_qc_list) => Ok(RepoQc::new(&self.path, cohort_qc_list)),
             Err(e) => Err(e),
         }
     }
@@ -81,9 +81,7 @@ mod tests {
     fn test_repo(repo_path: String) {
         let repo = GptRepository::new(&repo_path);
         let repoqc = repo.repo_qc().unwrap();
-        let count = repoqc.phenopacket_count();
-        println!("Total phenopackets: {}", count);
-        repoqc.check_moi();
+        
     }
 
 

src/repo/qc_report.rs

@@ -1,3 +1,5 @@
+use std::collections::HashSet;
+
 
 
 #[derive(Debug, Clone, serde::Serialize)] // Serialize helps if passing to a web-based GUI
@@ -11,21 +13,41 @@ pub struct QcReport {
 
 
 impl QcReport {
-    pub fn no_unepected_files(cohort_name: &str) -> Self {
-        Self { 
-            cohort_name: cohort_name.to_string(), 
-            message: "No unexpected files".to_string(), 
-            is_ok: true }
-    }
+    
 
-    pub fn unexpected_files(cohort_name: &str, unexpected: &Vec<String>) -> Self {
-        let msg = format!("Unexpected files: {}", unexpected.join("; "));
+    pub fn unexpected_file(cohort_name: &str, unexpected: &str) -> Self {
+        let msg = format!("Unexpected file: {}", unexpected);
         Self { cohort_name: cohort_name.to_string(), 
             message: msg, 
             is_ok: false 
         }
     }
 
+    pub fn moi_mismatch(cohort_name: &str, ppkt_id: &str, allowable_allele_counts: &HashSet<usize>, ac: usize) -> Self {
+        let set = format!(
+            "{{{}}}",
+            allowable_allele_counts
+                .iter()
+                .map(|n| n.to_string())
+                .collect::<Vec<_>>()
+                .join(",")
+        );
+        let message= format!("Expected counts of {} but got {} for {}.", set,ac, ppkt_id);
+        Self { cohort_name: cohort_name.to_string(), 
+            message, 
+            is_ok: false 
+        }
+    }
+
+    pub fn count_mismatch(cohort_name: &str, n_nrows: usize, n_phenopackets: usize) -> Self {
+        let message = format!("Rows: {} - exported phenopackets: {}", n_nrows, n_phenopackets);
+        Self {
+            cohort_name: cohort_name.to_string(),
+            message,
+            is_ok: false,
+        }
+    }
+
 
 
 }

src/repo/repo_qc.rs

@@ -1,35 +1,50 @@
-use crate::repo::{cohort_qc::CohortQc};
+use std::path::PathBuf;
+
+use crate::repo::{cohort_qc::CohortQc, qc_report::QcReport};
 
 
 
 
 pub struct RepoQc {
-    cohort_qc_list: Vec<CohortQc>
+    pub repo_path: String,
+    pub cohort_count: usize,
+    pub phenopacket_count: usize,
+    pub errors: Vec<QcReport>
 }
 
 
 impl RepoQc {
-    pub fn new(cohort_qc_list: Vec<CohortQc>) -> Self {
+    pub fn new(repository_path: &PathBuf, cohort_qc_list: Vec<CohortQc>) -> Self {
+        let phenopacket_count = Self::phenopacket_count(&cohort_qc_list);
+        let cohort_count = cohort_qc_list.len();
+        let repo_path: String = repository_path.to_string_lossy().to_string();
+        let errors = Self::get_errors(cohort_qc_list);
         Self {
-            cohort_qc_list
+            repo_path,
+            cohort_count,
+            phenopacket_count,
+            errors
         }
     }
 
-    pub fn phenopacket_count(&self) -> usize {
+    pub fn phenopacket_count(cohort_qc_list: &Vec<CohortQc>) -> usize {
         let mut c = 0 as usize;
-        for cohort in &self.cohort_qc_list {
+        for cohort in cohort_qc_list {
             c += cohort.ppkt_count();
         }
         return c;
     }
 
-    pub fn check_moi(&self) {
-        println!("Checking agreement of MOI and allele counts");
-        let mut misfit = 0 as usize;
-        for cohort in &self.cohort_qc_list {
-            misfit += cohort.check_moi();
+    fn get_errors(cohort_qc_list: Vec<CohortQc>) -> Vec<QcReport> {
+        let mut errs: Vec<QcReport> = Vec::new();
+        for cohort in cohort_qc_list {
+            let cohort_errs = cohort.get_errors();
+            errs.extend(cohort_errs);
         }
-         println!("Found misalignment in {} cohorts", misfit);
+
+        errs
     }
 
+    
+
 }