@sjcrh/proteinpaint-rust 2.132.1-0 → 2.135.0

package/package.json

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

package/src/gdcGRIN2.rs

@@ -6,14 +6,18 @@
   2. Better timeout handling with retries
   3. More detailed error reporting
   4. Continues processing even when some files fail
+  5. Added chromosome filtering
 
   Input JSON:
     caseFiles
     mafOptions: For SNVindel filtering
+    cnvOptions: For CNV filtering
+    chromosomes: chromosomes will be included:[]
+
   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,"hyperMutator":1000,"consequences":["missense_variant","frameshift_variant"]}, "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":8000,"consequences":["missense_variant","frameshift_variant"]}, "cnvOptions":{"lossThreshold":-1, "gainThreshold": 1.5, "segLength":2000000, "hyperMutator":8000}, "chromosomes":["chr1","chr2","chr3"]}' | ./target/release/gdcGRIN2
 */
 
 use flate2::read::GzDecoder;
@@ -21,7 +25,7 @@ use futures::StreamExt;
 use memchr::memchr;
 use serde::{Deserialize, Serialize};
 use serde_json;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::io::{self, Read};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -69,6 +73,8 @@ struct CnvOptions {
     gain_threshold: f32,
     #[serde(rename = "segLength")]
     seg_length: i32,
+    #[serde(rename = "hyperMutator")]
+    hyper_mutator: i32,
 }
 
 // Individual successful file output (JSONL format)
@@ -94,6 +100,7 @@ struct FilteredMafDetails {
     excluded_by_consequence_type: usize,
     total_processed: usize,
     total_included: usize,
+    skipped_chromosomes: HashMap<String, usize>,
 }
 
 // struct for CNV filter details
@@ -107,6 +114,7 @@ struct FilteredCnvDetails {
     excluded_by_segment_length: usize,
     total_processed: usize,
     total_included: usize,
+    skipped_chromosomes: HashMap<String, usize>,
 }
 
 // struct for per-case filter details
@@ -131,7 +139,7 @@ struct FinalSummary {
     included_maf_records: usize,
     included_cnv_records: usize,
     filtered_records_by_case: HashMap<String, FilteredCaseDetails>,
-    hyper_mutator_records: Vec<String>,
+    hyper_mutator_records: HashMap<String, Vec<String>>,
 }
 
 // Define the top-level input structure
@@ -143,6 +151,7 @@ struct InputData {
     maf_options: Option<MafOptions>,
     #[serde(rename = "cnvOptions")]
     cnv_options: Option<CnvOptions>,
+    chromosomes: Vec<String>,
 }
 
 // Configuration for different data types
@@ -159,17 +168,19 @@ async fn parse_content(
     data_type: &str,
     min_total_depth: i32,
     min_alt_allele_count: i32,
-    hyper_mutator: i32,
+    maf_hyper_mutator: i32,
     consequences: &Option<Vec<String>>,
     gain_threshold: f32,
     loss_threshold: f32,
     seg_length: i32,
+    cnv_hyper_mutator: i32,
+    chromosomes: &HashSet<String>,
     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>>>,
+    hyper_mutator_records: &Arc<Mutex<HashMap<String, Vec<String>>>>,
 ) -> Result<Vec<Vec<String>>, (String, String, String)> {
     let config = match data_type {
         "cnv" => DataTypeConfig {
@@ -189,13 +200,24 @@ async fn parse_content(
         }
     };
 
-    // check hyperMutator for MAF files
-    if data_type == "maf" && hyper_mutator > 0 {
+    // check hyperMutator for MAF and CNV files
+    let hyper_mutator = if data_type == "maf" {
+        maf_hyper_mutator
+    } else {
+        cnv_hyper_mutator
+    };
+    if 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());
+            hyper_records
+                .entry(data_type.to_string())
+                .or_insert_with(Vec::new)
+                .push(case_id.to_string());
+            if data_type == "maf" {
+                filtered_maf_records.fetch_add(line_count, Ordering::Relaxed);
+            } else if data_type == "cnv" {
+                filtered_cnv_records.fetch_add(line_count, Ordering::Relaxed);
             }
             return Ok(Vec::new());
         }
@@ -205,9 +227,6 @@ async fn parse_content(
     let mut parsed_data = Vec::new();
     let mut columns_indices: Vec<usize> = Vec::new();
     let mut variant_classification_index: Option<usize> = None;
-    //let mut header_mk: &str = "";
-    //let mut columns = Vec::new();
-
     let mut header: Vec<String> = Vec::new();
 
     for line in lines {
@@ -229,26 +248,49 @@ async fn parse_content(
             continue;
         };
 
-        let row = process_row(
-            line,
-            case_id,
-            data_type,
-            &header,
-            &columns_indices,
-            variant_classification_index,
-            consequences,
-            min_total_depth,
-            min_alt_allele_count,
-            gain_threshold,
-            loss_threshold,
-            seg_length,
-            filtered_records,
-            filtered_maf_records,
-            filtered_cnv_records,
-            included_maf_records,
-            included_cnv_records,
-        )
-        .await?;
+        let row = match data_type {
+            "maf" => {
+                process_mafline(
+                    line,
+                    case_id,
+                    data_type,
+                    &columns_indices,
+                    variant_classification_index,
+                    consequences,
+                    min_total_depth,
+                    min_alt_allele_count,
+                    chromosomes,
+                    filtered_records,
+                    filtered_maf_records,
+                    included_maf_records,
+                )
+                .await
+            }
+            "cnv" => {
+                process_cnvline(
+                    line,
+                    case_id,
+                    data_type,
+                    &header,
+                    &columns_indices,
+                    gain_threshold,
+                    loss_threshold,
+                    seg_length,
+                    chromosomes,
+                    filtered_records,
+                    filtered_cnv_records,
+                    included_cnv_records,
+                )
+                .await
+            }
+            _ => {
+                return Err((
+                    case_id.to_string(),
+                    data_type.to_string(),
+                    "Invalid data type".to_string(),
+                ));
+            }
+        }?;
 
         if let Some(out_lst) = row {
             parsed_data.push(out_lst);
@@ -302,25 +344,20 @@ fn setup_columns(
     Ok(())
 }
 
-// Process a single row of data
-async fn process_row(
+// Process a single row of MAF file
+async fn process_mafline(
     line: &str,
     case_id: &str,
     data_type: &str,
-    header: &[String],
     columns_indices: &[usize],
     variant_classification_index: Option<usize>,
     consequences: &Option<Vec<String>>,
     min_total_depth: i32,
     min_alt_allele_count: i32,
-    gain_threshold: f32,
-    loss_threshold: f32,
-    seg_length: i32,
+    chromosomes: &HashSet<String>,
     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()];
@@ -333,51 +370,38 @@ async fn process_row(
             maf: FilteredMafDetails::default(),
             cnv: FilteredCnvDetails::default(),
         });
-
     let case_details = filtered_map.get_mut(case_id).unwrap();
 
     // 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;
-    }
+    case_details.maf.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
+
+    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 {
-                    // No filter, count as matched
+                    // Empty filter, count as matched
                     *case_details
                         .maf
                         .matched_consequences
@@ -385,32 +409,142 @@ async fn process_row(
                         .or_insert(0) += 1;
                 }
             } else {
-                case_details.maf.invalid_rows += 1;
-                filtered_maf_records.fetch_add(1, Ordering::Relaxed);
-                return Ok(None);
+                // 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
     for &x in columns_indices {
         if x >= cont_lst.len() {
-            if data_type == "maf" {
-                case_details.maf.invalid_rows += 1;
-                filtered_maf_records.fetch_add(1, Ordering::Relaxed);
-            } else if data_type == "cnv" {
-                case_details.cnv.invalid_rows += 1;
-                filtered_cnv_records.fetch_add(1, Ordering::Relaxed);
-            }
+            case_details.maf.invalid_rows += 1;
+            filtered_maf_records.fetch_add(1, Ordering::Relaxed);
             return Ok(None); // Invalid row
         }
+        let element = cont_lst[x].to_string();
+        out_lst.push(element);
+    }
+
+    // Additional MAF-specific processing
+    if out_lst.len() < 6 {
+        case_details.maf.invalid_rows += 1;
+        filtered_maf_records.fetch_add(1, Ordering::Relaxed);
+        return Ok(None); // Not enough columns
+    }
+
+    let alle_depth = out_lst[4].parse::<i32>().map_err(|_| {
+        case_details.maf.invalid_rows += 1;
+        filtered_maf_records.fetch_add(1, Ordering::Relaxed);
+        (
+            case_id.to_string(),
+            data_type.to_string(),
+            "Failed to convert t_depth to integer.".to_string(),
+        )
+    })?;
+
+    let alt_count = out_lst[5].parse::<i32>().map_err(|_| {
+        case_details.maf.invalid_rows += 1;
+        filtered_maf_records.fetch_add(1, Ordering::Relaxed);
+        (
+            case_id.to_string(),
+            data_type.to_string(),
+            "Failed to convert t_alt_count to integer.".to_string(),
+        )
+    })?;
+
+    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);
+    }
+
+    // Keep case_id, chr, start, end, and add "mutation"
+    out_lst = out_lst[0..4].to_vec();
+    out_lst.push("mutation".to_string());
+
+    // adding 'chr' to chromosome if it is not start with 'chr'
+    if !out_lst[1].starts_with("chr") {
+        out_lst[1] = format!("chr{}", out_lst[1]);
+    }
+
+    // Chromosome filtering
+    if !chromosomes.is_empty() && !chromosomes.contains(&out_lst[1]) {
+        *case_details
+            .maf
+            .skipped_chromosomes
+            .entry(out_lst[1].clone())
+            .or_insert(0) += 1;
+        filtered_maf_records.fetch_add(1, Ordering::Relaxed);
+        return Ok(None);
+    }
+
+    // Update counters for included MAF records
+    case_details.maf.total_included += 1;
+    included_maf_records.fetch_add(1, Ordering::Relaxed);
+
+    Ok(Some(out_lst))
+}
+
+// Process a single row of CNV file
+async fn process_cnvline(
+    line: &str,
+    case_id: &str,
+    data_type: &str,
+    header: &[String],
+    columns_indices: &[usize],
+    gain_threshold: f32,
+    loss_threshold: f32,
+    seg_length: i32,
+    chromosomes: &HashSet<String>,
+    filtered_records: &Arc<Mutex<HashMap<String, FilteredCaseDetails>>>,
+    filtered_cnv_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()];
+
+    // Initialize or update case details
+    let mut filtered_map = filtered_records.lock().await;
+    filtered_map
+        .entry(case_id.to_string())
+        .or_insert_with(|| FilteredCaseDetails {
+            maf: FilteredMafDetails::default(),
+            cnv: FilteredCnvDetails::default(),
+        });
+    let case_details = filtered_map.get_mut(case_id).unwrap();
+
+    // Track total processed records
+    case_details.cnv.total_processed += 1;
 
+    // Extract relevant columns
+    for &x in columns_indices {
+        if x >= cont_lst.len() {
+            case_details.cnv.invalid_rows += 1;
+            filtered_cnv_records.fetch_add(1, Ordering::Relaxed);
+            return Ok(None); // Invalid row
+        }
         let mut element = cont_lst[x].to_string();
-        if data_type == "cnv" && header[x] == "Segment_Mean" {
+        if header[x] == "Segment_Mean" {
             element = process_segment_mean(&element, case_id, data_type, gain_threshold, loss_threshold)?;
             if element.is_empty() {
                 case_details.cnv.segment_mean += 1;
@@ -430,89 +564,55 @@ async fn process_row(
         out_lst.push(element);
     }
 
-    // Additional MAF-specific processing
-    if data_type == "maf" {
-        if out_lst.len() < 6 {
-            case_details.maf.invalid_rows += 1;
-            filtered_maf_records.fetch_add(1, Ordering::Relaxed);
-            return Ok(None); // Not enough columns
-        }
-
-        let alle_depth = out_lst[4].parse::<i32>().map_err(|_| {
-            case_details.maf.invalid_rows += 1;
-            filtered_maf_records.fetch_add(1, Ordering::Relaxed);
-            (
-                case_id.to_string(),
-                data_type.to_string(),
-                "Failed to convert t_depth to integer.".to_string(),
-            )
-        })?;
-
-        let alt_count = out_lst[5].parse::<i32>().map_err(|_| {
-            case_details.maf.invalid_rows += 1;
-            filtered_maf_records.fetch_add(1, Ordering::Relaxed);
-            (
-                case_id.to_string(),
-                data_type.to_string(),
-                "Failed to convert t_alt_count to integer.".to_string(),
-            )
-        })?;
-
-        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);
-        }
-
-        // Keep case_id, chr, start, end, and add "mutation"
-        out_lst = out_lst[0..4].to_vec();
-        out_lst.push("mutation".to_string());
+    // filter cnvs based on segment length. Default: 0 (no filtering)
+    // calculate segment length (End_Position - Start_Position)
+    let end_position = out_lst[3].parse::<i32>().map_err(|_| {
+        case_details.cnv.invalid_rows += 1;
+        filtered_cnv_records.fetch_add(1, Ordering::Relaxed);
+        (
+            case_id.to_string(),
+            data_type.to_string(),
+            "Failed to convert End Position of cnv to integer.".to_string(),
+        )
+    })?;
 
-        // Update counters for included MAF records
-        case_details.maf.total_included += 1;
-        included_maf_records.fetch_add(1, Ordering::Relaxed);
+    let start_position = out_lst[2].parse::<i32>().map_err(|_| {
+        case_details.cnv.invalid_rows += 1;
+        filtered_cnv_records.fetch_add(1, Ordering::Relaxed);
+        (
+            case_id.to_string(),
+            data_type.to_string(),
+            "Failed to convert Start Position of cnv to integer.".to_string(),
+        )
+    })?;
+    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);
     }
 
-    // filter cnvs based on segment length. Default: 0 (no filtering)
-    if data_type == "cnv" {
-        // calculate segment length (End_Position - Start_Position)
-        let end_position = out_lst[3].parse::<i32>().map_err(|_| {
-            case_details.cnv.invalid_rows += 1;
-            filtered_cnv_records.fetch_add(1, Ordering::Relaxed);
-            (
-                case_id.to_string(),
-                data_type.to_string(),
-                "Failed to convert End Position of cnv to integer.".to_string(),
-            )
-        })?;
+    // adding 'chr' to chromosome if it is not start with 'chr'
+    if !out_lst[1].starts_with("chr") {
+        out_lst[1] = format!("chr{}", out_lst[1]);
+    }
 
-        let start_position = out_lst[2].parse::<i32>().map_err(|_| {
-            case_details.cnv.invalid_rows += 1;
-            filtered_cnv_records.fetch_add(1, Ordering::Relaxed);
-            (
-                case_id.to_string(),
-                data_type.to_string(),
-                "Failed to convert Start Position of cnv to integer.".to_string(),
-            )
-        })?;
-        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);
+    // Chromosome filtering
+    if !chromosomes.is_empty() && !chromosomes.contains(&out_lst[1]) {
+        *case_details
+            .cnv
+            .skipped_chromosomes
+            .entry(out_lst[1].clone())
+            .or_insert(0) += 1;
+        filtered_cnv_records.fetch_add(1, Ordering::Relaxed);
+        return Ok(None);
     }
 
+    // Update counters for included MAF records
+    case_details.cnv.total_included += 1;
+    included_cnv_records.fetch_add(1, Ordering::Relaxed);
+
     Ok(Some(out_lst))
 }
 
@@ -652,11 +752,13 @@ async fn download_data_streaming(
     host: &str,
     min_total_depth: i32,
     min_alt_allele_count: i32,
-    hyper_mutator: i32,
+    maf_hyper_mutator: i32,
     consequences: &Option<Vec<String>>,
     gain_threshold: f32,
     loss_threshold: f32,
     seg_length: i32,
+    cnv_hyper_mutator: i32,
+    chromosomes: &HashSet<String>,
 ) {
     let data_urls: Vec<(String, String, String)> = data4dl
         .into_iter()
@@ -680,7 +782,7 @@ 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 hyper_mutator_records = Arc::new(Mutex::new(HashMap::<String, Vec<String>>::new()));
     let included_maf_records = Arc::new(AtomicUsize::new(0));
     let included_cnv_records = Arc::new(AtomicUsize::new(0));
 
@@ -717,11 +819,13 @@ async fn download_data_streaming(
                             &data_type,
                             min_total_depth,
                             min_alt_allele_count,
-                            hyper_mutator,
+                            maf_hyper_mutator,
                             &consequences,
                             gain_threshold,
                             loss_threshold,
                             seg_length,
+                            cnv_hyper_mutator,
+                            &chromosomes,
                             &filtered_records,
                             &filtered_maf_records,
                             &filtered_cnv_records,
@@ -865,7 +969,7 @@ 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, hyper_mutator, consequences) = match input_js.maf_options {
+    let (min_total_depth, min_alt_allele_count, maf_hyper_mutator, consequences) = match input_js.maf_options {
         Some(options) => (
             options.min_total_depth,
             options.min_alt_allele_count,
@@ -876,22 +980,32 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
 
     // Set default cnv_options
-    let (gain_threshold, loss_threshold, seg_length) = match input_js.cnv_options {
-        Some(options) => (options.gain_threshold, options.loss_threshold, options.seg_length),
-        None => (0.3, -0.4, 0), // Default values
+    let (gain_threshold, loss_threshold, seg_length, cnv_hyper_mutator) = match input_js.cnv_options {
+        Some(options) => (
+            options.gain_threshold,
+            options.loss_threshold,
+            options.seg_length,
+            options.hyper_mutator,
+        ),
+        None => (0.3, -0.4, 0, 500), // Default values
     };
 
+    // Convert Vec<String> to HashSet<String> for faster lookup
+    let chromosomes = input_js.chromosomes.into_iter().collect::<HashSet<String>>();
+
     // Download data - this will now handle errors gracefully
     download_data_streaming(
         case_files,
         HOST,
         min_total_depth,
         min_alt_allele_count,
-        hyper_mutator,
+        maf_hyper_mutator,
         &consequences,
         gain_threshold,
         loss_threshold,
         seg_length,
+        cnv_hyper_mutator,
+        &chromosomes,
     )
     .await;