@sjcrh/proteinpaint-rust 2.130.0 → 2.132.1-0

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.130.0",
+	"version": "2.132.1-0",
 	"name": "@sjcrh/proteinpaint-rust",
 	"type": "module",
 	"description": "Rust-based utilities for proteinpaint",

package/src/gdcGRIN2.rs

@@ -13,7 +13,7 @@
   Output mutations as JSON array.
 
   Example of usage:
-    echo '{"caseFiles": {"MP2PRT-PATFJE": {"maf": "26ea7b6f-8bc4-4e83-ace1-2125b493a361"},"MP2PRT-PAPIGD": {"maf": "653d7458-f4af-4328-a1ce-3bbf22a2e347"}, "TCGA-CG-4300": { "cnv":"46372ec2-ff79-4d07-b375-9ba8a12c11f3", "maf":"c09b208d-2e7b-4116-9580-27f20f4c7e67"}},"mafOptions": {"minTotalDepth": 100,"minAltAlleleCount": 20}, "cnvOptions":{"lossThreshold":-1, "gainThreshold": 1.5, "segLength":2000000}}' | ./target/release/gdcGRIN2
+    echo '{"caseFiles": {"MP2PRT-PATFJE": {"maf": "26ea7b6f-8bc4-4e83-ace1-2125b493a361"},"MP2PRT-PAPIGD": {"maf": "653d7458-f4af-4328-a1ce-3bbf22a2e347"}, "TCGA-CG-4300": { "cnv":"46372ec2-ff79-4d07-b375-9ba8a12c11f3", "maf":"c09b208d-2e7b-4116-9580-27f20f4c7e67"}},"mafOptions": {"minTotalDepth": 100,"minAltAlleleCount": 20,"hyperMutator":1000,"consequences":["missense_variant","frameshift_variant"]}, "cnvOptions":{"lossThreshold":-1, "gainThreshold": 1.5, "segLength":2000000}}' | ./target/release/gdcGRIN2
 */
 
 use flate2::read::GzDecoder;
@@ -55,6 +55,8 @@ struct MafOptions {
     min_total_depth: i32,
     #[serde(rename = "minAltAlleleCount")]
     min_alt_allele_count: i32,
+    #[serde(rename = "hyperMutator")]
+    hyper_mutator: i32,
     consequences: Option<Vec<String>>, // Optional list of consequences to filter MAF files
 }
 
@@ -82,10 +84,16 @@ struct SuccessfulFileOutput {
 // struct for MAF filter details
 #[derive(Clone, Serialize, Default)]
 struct FilteredMafDetails {
-    invalid_consequences: usize,
+    matched_consequences: HashMap<String, usize>,
+    rejected_consequences: HashMap<String, usize>,
     t_alt_count: usize,
     t_depth: usize,
     invalid_rows: usize,
+    excluded_by_min_depth: usize,
+    excluded_by_min_alt_count: usize,
+    excluded_by_consequence_type: usize,
+    total_processed: usize,
+    total_included: usize,
 }
 
 // struct for CNV filter details
@@ -94,6 +102,11 @@ struct FilteredCnvDetails {
     segment_mean: usize,
     seg_length: usize,
     invalid_rows: usize,
+    excluded_by_loss_threshold: usize,
+    excluded_by_gain_threshold: usize,
+    excluded_by_segment_length: usize,
+    total_processed: usize,
+    total_included: usize,
 }
 
 // struct for per-case filter details
@@ -115,7 +128,10 @@ struct FinalSummary {
     filtered_records: usize,
     filtered_maf_records: usize,
     filtered_cnv_records: usize,
+    included_maf_records: usize,
+    included_cnv_records: usize,
     filtered_records_by_case: HashMap<String, FilteredCaseDetails>,
+    hyper_mutator_records: Vec<String>,
 }
 
 // Define the top-level input structure
@@ -143,6 +159,7 @@ async fn parse_content(
     data_type: &str,
     min_total_depth: i32,
     min_alt_allele_count: i32,
+    hyper_mutator: i32,
     consequences: &Option<Vec<String>>,
     gain_threshold: f32,
     loss_threshold: f32,
@@ -150,6 +167,9 @@ async fn parse_content(
     filtered_records: &Arc<Mutex<HashMap<String, FilteredCaseDetails>>>,
     filtered_maf_records: &AtomicUsize,
     filtered_cnv_records: &AtomicUsize,
+    included_maf_records: &AtomicUsize,
+    included_cnv_records: &AtomicUsize,
+    hyper_mutator_records: &Arc<Mutex<Vec<String>>>,
 ) -> Result<Vec<Vec<String>>, (String, String, String)> {
     let config = match data_type {
         "cnv" => DataTypeConfig {
@@ -169,6 +189,18 @@ async fn parse_content(
         }
     };
 
+    // check hyperMutator for MAF files
+    if data_type == "maf" && hyper_mutator > 0 {
+        let line_count = content.lines().count();
+        if line_count as i32 > hyper_mutator {
+            let mut hyper_records = hyper_mutator_records.lock().await;
+            if !hyper_records.contains(&case_id.to_string()) {
+                hyper_records.push(case_id.to_string());
+            }
+            return Ok(Vec::new());
+        }
+    };
+
     let lines = content.lines();
     let mut parsed_data = Vec::new();
     let mut columns_indices: Vec<usize> = Vec::new();
@@ -213,6 +245,8 @@ async fn parse_content(
             filtered_records,
             filtered_maf_records,
             filtered_cnv_records,
+            included_maf_records,
+            included_cnv_records,
         )
         .await?;
 
@@ -255,7 +289,7 @@ fn setup_columns(
     }
 
     if data_type == "maf" {
-        *variant_classification_index = header.iter().position(|x| x == "Variant_Classification");
+        *variant_classification_index = header.iter().position(|x| x == "One_Consequence");
         if variant_classification_index.is_none() {
             return Err((
                 case_id.to_string(),
@@ -285,6 +319,8 @@ async fn process_row(
     filtered_records: &Arc<Mutex<HashMap<String, FilteredCaseDetails>>>,
     filtered_maf_records: &AtomicUsize,
     filtered_cnv_records: &AtomicUsize,
+    included_maf_records: &AtomicUsize,
+    included_cnv_records: &AtomicUsize,
 ) -> Result<Option<Vec<String>>, (String, String, String)> {
     let cont_lst: Vec<String> = line.split("\t").map(|s| s.to_string()).collect();
     let mut out_lst = vec![case_id.to_string()];
@@ -300,11 +336,64 @@ async fn process_row(
 
     let case_details = filtered_map.get_mut(case_id).unwrap();
 
-    // Check consequence filtering for MAF files
-    if data_type == "maf" && !is_valid_consequence(&cont_lst, variant_classification_index, consequences) {
-        case_details.maf.invalid_consequences += 1;
-        filtered_maf_records.fetch_add(1, Ordering::Relaxed);
-        return Ok(None);
+    // Track total processed records
+    if data_type == "maf" {
+        case_details.maf.total_processed += 1;
+    } else if data_type == "cnv" {
+        case_details.cnv.total_processed += 1;
+    }
+
+    // Handle consequence filtering and counting for MAF files
+    if data_type == "maf" {
+        if let Some(var_class_idx) = variant_classification_index {
+            if var_class_idx < cont_lst.len() {
+                let variant_classification = &cont_lst[var_class_idx];
+                if let Some(consequence_filter) = consequences {
+                    if !consequence_filter.is_empty() {
+                        if consequence_filter.contains(variant_classification) {
+                            // Matched consequence
+                            *case_details
+                                .maf
+                                .matched_consequences
+                                .entry(variant_classification.to_string())
+                                .or_insert(0) += 1;
+                        } else {
+                            // Unmatched consequence
+                            *case_details
+                                .maf
+                                .rejected_consequences
+                                .entry(variant_classification.to_string())
+                                .or_insert(0) += 1;
+                            case_details.maf.excluded_by_consequence_type += 1;
+                            filtered_maf_records.fetch_add(1, Ordering::Relaxed);
+                            return Ok(None);
+                        }
+                    } else {
+                        // Empty filter, count as matched
+                        *case_details
+                            .maf
+                            .matched_consequences
+                            .entry(variant_classification.to_string())
+                            .or_insert(0) += 1;
+                    }
+                } else {
+                    // No filter, count as matched
+                    *case_details
+                        .maf
+                        .matched_consequences
+                        .entry(variant_classification.to_string())
+                        .or_insert(0) += 1;
+                }
+            } else {
+                case_details.maf.invalid_rows += 1;
+                filtered_maf_records.fetch_add(1, Ordering::Relaxed);
+                return Ok(None);
+            }
+        } else {
+            case_details.maf.invalid_rows += 1;
+            filtered_maf_records.fetch_add(1, Ordering::Relaxed);
+            return Ok(None);
+        }
     }
 
     // Extract relevant columns
@@ -325,6 +414,15 @@ async fn process_row(
             element = process_segment_mean(&element, case_id, data_type, gain_threshold, loss_threshold)?;
             if element.is_empty() {
                 case_details.cnv.segment_mean += 1;
+                let seg_mean = cont_lst[x].parse::<f32>().unwrap_or(0.0);
+                if seg_mean > loss_threshold && seg_mean < gain_threshold {
+                    // Between thresholds - not a significant gain or loss
+                    if seg_mean >= 0.0 {
+                        case_details.cnv.excluded_by_gain_threshold += 1;
+                    } else {
+                        case_details.cnv.excluded_by_loss_threshold += 1;
+                    }
+                }
                 filtered_cnv_records.fetch_add(1, Ordering::Relaxed);
                 return Ok(None);
             }
@@ -362,11 +460,13 @@ async fn process_row(
 
         if alle_depth < min_total_depth {
             case_details.maf.t_depth += 1;
+            case_details.maf.excluded_by_min_depth += 1;
             filtered_maf_records.fetch_add(1, Ordering::Relaxed);
             return Ok(None);
         }
         if alt_count < min_alt_allele_count {
             case_details.maf.t_alt_count += 1;
+            case_details.maf.excluded_by_min_alt_count += 1;
             filtered_maf_records.fetch_add(1, Ordering::Relaxed);
             return Ok(None);
         }
@@ -374,6 +474,10 @@ async fn process_row(
         // Keep case_id, chr, start, end, and add "mutation"
         out_lst = out_lst[0..4].to_vec();
         out_lst.push("mutation".to_string());
+
+        // Update counters for included MAF records
+        case_details.maf.total_included += 1;
+        included_maf_records.fetch_add(1, Ordering::Relaxed);
     }
 
     // filter cnvs based on segment length. Default: 0 (no filtering)
@@ -401,36 +505,17 @@ async fn process_row(
         let cnv_length = end_position - start_position;
         if seg_length > 0 && cnv_length > seg_length {
             case_details.cnv.seg_length += 1;
+            case_details.cnv.excluded_by_segment_length += 1;
             filtered_cnv_records.fetch_add(1, Ordering::Relaxed);
             return Ok(None);
         }
+        case_details.cnv.total_included += 1;
+        included_cnv_records.fetch_add(1, Ordering::Relaxed);
     }
 
     Ok(Some(out_lst))
 }
 
-// Check if the row meets consequence filtering criteria
-fn is_valid_consequence(
-    cont_lst: &[String],
-    variant_classification_index: Option<usize>,
-    consequences: &Option<Vec<String>>,
-) -> bool {
-    if let Some(consequence_filter) = consequences {
-        if !consequence_filter.is_empty() {
-            if let Some(var_class_idx) = variant_classification_index {
-                if var_class_idx < cont_lst.len() {
-                    let variant_classification = &cont_lst[var_class_idx];
-                    if let Some(normalized_consequence) = normalize_consequence(variant_classification) {
-                        return consequence_filter.contains(&normalized_consequence);
-                    }
-                }
-                return false; // Invalid row or unknown consequence
-            }
-        }
-    }
-    true // No filtering or empty filter
-}
-
 // Process Segment_Mean for CNV files
 fn process_segment_mean(
     element: &str,
@@ -457,23 +542,6 @@ fn process_segment_mean(
 }
 
 /// Updated helper function to normalize MAF consequence types to frontend format
-/// Returns None for unknown consequence types (which will be filtered out)
-fn normalize_consequence(maf_consequence: &str) -> Option<String> {
-    match maf_consequence.to_lowercase().as_str() {
-        // Only map the consequence types we actually support
-        "missense_mutation" => Some("missense".to_string()),
-        "nonsense_mutation" | "stop_gained" | "stop_lost" => Some("nonsense".to_string()),
-        "frame_shift_del" | "frame_shift_ins" | "frameshift_variant" => Some("frameshift".to_string()),
-        "silent" | "synonymous_variant" => Some("silent".to_string()),
-        "in_frame_del" => Some("deletion".to_string()),
-        "in_frame_ins" => Some("insertion".to_string()),
-        "splice_site" | "splice_acceptor_variant" | "splice_donor_variant" => Some("splice_site".to_string()),
-        "tandem_duplication" | "duplication" => Some("duplication".to_string()),
-        "inversion" => Some("inversion".to_string()),
-        // Return None for all unknown consequence types - they will be filtered out
-        _ => None,
-    }
-}
 /// Downloads a single file with minimal retry logic for transient failures
 async fn download_single_file(
     case_id: String,
@@ -584,6 +652,7 @@ async fn download_data_streaming(
     host: &str,
     min_total_depth: i32,
     min_alt_allele_count: i32,
+    hyper_mutator: i32,
     consequences: &Option<Vec<String>>,
     gain_threshold: f32,
     loss_threshold: f32,
@@ -611,6 +680,9 @@ async fn download_data_streaming(
     let filtered_maf_records = Arc::new(AtomicUsize::new(0));
     let filtered_cnv_records = Arc::new(AtomicUsize::new(0));
     let filtered_records = Arc::new(Mutex::new(HashMap::<String, FilteredCaseDetails>::new()));
+    let hyper_mutator_records = Arc::new(Mutex::new(Vec::<String>::new()));
+    let included_maf_records = Arc::new(AtomicUsize::new(0));
+    let included_cnv_records = Arc::new(AtomicUsize::new(0));
 
     // Only collect errors (successful data is output immediately)
     let errors = Arc::new(Mutex::new(Vec::<ErrorEntry>::new()));
@@ -630,6 +702,9 @@ async fn download_data_streaming(
             let filtered_maf_records = Arc::clone(&filtered_maf_records);
             let filtered_cnv_records = Arc::clone(&filtered_cnv_records);
             let filtered_records = Arc::clone(&filtered_records);
+            let included_maf_records = Arc::clone(&included_maf_records);
+            let included_cnv_records = Arc::clone(&included_cnv_records);
+            let hyper_mutator_records = Arc::clone(&hyper_mutator_records);
             let errors = Arc::clone(&errors);
 
             async move {
@@ -642,6 +717,7 @@ async fn download_data_streaming(
                             &data_type,
                             min_total_depth,
                             min_alt_allele_count,
+                            hyper_mutator,
                             &consequences,
                             gain_threshold,
                             loss_threshold,
@@ -649,6 +725,9 @@ async fn download_data_streaming(
                             &filtered_records,
                             &filtered_maf_records,
                             &filtered_cnv_records,
+                            &included_maf_records,
+                            &included_cnv_records,
+                            &hyper_mutator_records,
                         )
                         .await
                         {
@@ -717,6 +796,8 @@ async fn download_data_streaming(
     let failed_count = failed_downloads.load(Ordering::Relaxed);
     let filtered_maf_count = filtered_maf_records.load(Ordering::Relaxed);
     let filtered_cnv_count = filtered_cnv_records.load(Ordering::Relaxed);
+    let included_maf_count = included_maf_records.load(Ordering::Relaxed);
+    let included_cnv_count = included_cnv_records.load(Ordering::Relaxed);
 
     let summary = FinalSummary {
         output_type: "summary".to_string(),
@@ -728,6 +809,9 @@ async fn download_data_streaming(
         filtered_maf_records: filtered_maf_count,
         filtered_cnv_records: filtered_cnv_count,
         filtered_records_by_case: filtered_records.lock().await.clone(),
+        included_maf_records: included_maf_count,
+        included_cnv_records: included_cnv_count,
+        hyper_mutator_records: hyper_mutator_records.lock().await.clone(),
     };
 
     // Output final summary - Node.js will know processing is complete when it sees this
@@ -781,13 +865,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let case_files = input_js.case_files;
 
     // Set default maf_options
-    let (min_total_depth, min_alt_allele_count, consequences) = match input_js.maf_options {
+    let (min_total_depth, min_alt_allele_count, hyper_mutator, consequences) = match input_js.maf_options {
         Some(options) => (
             options.min_total_depth,
             options.min_alt_allele_count,
+            options.hyper_mutator,
             options.consequences.clone(),
         ),
-        None => (10, 2, None), // Default values
+        None => (10, 2, 8000, None), // Default values
     };
 
     // Set default cnv_options
@@ -802,6 +887,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         HOST,
         min_total_depth,
         min_alt_allele_count,
+        hyper_mutator,
         &consequences,
         gain_threshold,
         loss_threshold,