@sjcrh/proteinpaint-rust 2.122.0 → 2.124.0

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.122.0",
+	"version": "2.124.0",
 	"name": "@sjcrh/proteinpaint-rust",
 	"type": "module",
 	"description": "Rust-based utilities for proteinpaint",
@@ -39,5 +39,5 @@
 	"devDependencies": {
 		"tape": "^5.2.2"
 	},
-	"pp_release_tag": "v2.122.0"
+	"pp_release_tag": "v2.124.0"
 }

package/src/gdcmaf.rs

@@ -10,16 +10,16 @@
     echo '{"host": "https://api.gdc.cancer.gov/data/","columns": ["Hugo_Symbol", "Entrez_Gene_Id", "Center", "NCBI_Build", "Chromosome", "Start_Position"], "fileIdLst": ["8b31d6d1-56f7-4aa8-b026-c64bafd531e7", "b429fcc1-2b59-4b4c-a472-fb27758f6249"]}'|./target/release/gdcmaf
 */
 
+use flate2::Compression;
 use flate2::read::GzDecoder;
 use flate2::write::GzEncoder;
-use flate2::Compression;
-use serde_json::{Value};
 use futures::StreamExt;
-use std::io::{self,Read,Write};
+use serde_json::Value;
+use std::io::{self, Read, Write};
+use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use tokio::io::{AsyncReadExt, BufReader};
 use tokio::time::timeout;
-use std::sync::{Arc, Mutex};
 
 // Struct to hold error information
 #[derive(serde::Serialize)]
@@ -28,14 +28,14 @@ struct ErrorEntry {
     error: String,
 }
 
-fn select_maf_col(d:String,columns:&Vec<String>,url:&str) -> Result<(Vec<u8>,i32), (String, String)> {
+fn select_maf_col(d: String, columns: &Vec<String>, url: &str) -> Result<(Vec<u8>, i32), (String, String)> {
     let mut maf_str: String = String::new();
     let mut header_indices: Vec<usize> = Vec::new();
     let lines = d.trim_end().split("\n");
     let mut mafrows = 0;
     for line in lines {
         if line.starts_with("#") {
-            continue
+            continue;
         } else if line.contains("Hugo_Symbol") {
             let header: Vec<String> = line.split("\t").map(|s| s.to_string()).collect();
             for col in columns {
@@ -48,7 +48,7 @@ fn select_maf_col(d:String,columns:&Vec<String>,url:&str) -> Result<(Vec<u8>,i32
                         return Err((url.to_string(), error_msg));
                     }
                 }
-            };
+            }
             if header_indices.is_empty() {
                 return Err((url.to_string(), "No matching columns found".to_string()));
             }
@@ -57,19 +57,17 @@ fn select_maf_col(d:String,columns:&Vec<String>,url:&str) -> Result<(Vec<u8>,i32
             let mut maf_out_lst: Vec<String> = Vec::new();
             for x in header_indices.iter() {
                 maf_out_lst.push(maf_cont_lst[*x].to_string());
-            };
+            }
             maf_str.push_str(maf_out_lst.join("\t").as_str());
             maf_str.push_str("\n");
             mafrows += 1;
         }
-    };
-    Ok((maf_str.as_bytes().to_vec(),mafrows))
+    }
+    Ok((maf_str.as_bytes().to_vec(), mafrows))
 }
 
-
-
 #[tokio::main]
-async fn main() -> Result<(),Box<dyn std::error::Error>> {
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Accepting the piped input json from jodejs and assign to the variable
     // host: GDC host
     // url: urls to download single maf files
@@ -84,23 +82,21 @@ async fn main() -> Result<(),Box<dyn std::error::Error>> {
     })
     .await;
     // Handle the result of the timeout operation
-    let  file_id_lst_js: Value = match result {
-        Ok(Ok(buffer)) => {
-            match serde_json::from_str(&buffer) {
-                Ok(js) => js,
-                Err(e) => {
-                    let stdin_error = ErrorEntry {
-                        url: String::new(),
-                        error: format!("JSON parsing error: {}", e),
-                    };
-                    writeln!(io::stderr(), "{}", serde_json::to_string(&stdin_error).unwrap()).unwrap();
-                    return Err(Box::new(std::io::Error::new(
-                        std::io::ErrorKind::InvalidInput,
-                        "JSON parsing error!",
-                    )) as Box<dyn std::error::Error>);
-                }
+    let file_id_lst_js: Value = match result {
+        Ok(Ok(buffer)) => match serde_json::from_str(&buffer) {
+            Ok(js) => js,
+            Err(e) => {
+                let stdin_error = ErrorEntry {
+                    url: String::new(),
+                    error: format!("JSON parsing error: {}", e),
+                };
+                writeln!(io::stderr(), "{}", serde_json::to_string(&stdin_error).unwrap()).unwrap();
+                return Err(Box::new(std::io::Error::new(
+                    std::io::ErrorKind::InvalidInput,
+                    "JSON parsing error!",
+                )) as Box<dyn std::error::Error>);
             }
-        }
+        },
         Ok(Err(_e)) => {
             let stdin_error = ErrorEntry {
                 url: String::new(),
@@ -128,22 +124,30 @@ async fn main() -> Result<(),Box<dyn std::error::Error>> {
     };
 
     // reading the input from PP
-    let host = file_id_lst_js.get("host").expect("Host was not provided").as_str().expect("Host is not a string");
+    let host = file_id_lst_js
+        .get("host")
+        .expect("Host was not provided")
+        .as_str()
+        .expect("Host is not a string");
     let mut url: Vec<String> = Vec::new();
-    let file_id_lst = file_id_lst_js.get("fileIdLst").expect("File ID list is missed!").as_array().expect("File ID list is not an array");
+    let file_id_lst = file_id_lst_js
+        .get("fileIdLst")
+        .expect("File ID list is missed!")
+        .as_array()
+        .expect("File ID list is not an array");
     for v in file_id_lst {
         //url.push(Path::new(&host).join(&v.as_str().unwrap()).display().to_string());
-        url.push(format!("{}/{}",host.trim_end_matches('/'), v.as_str().unwrap()));
-    };
+        url.push(format!("{}/{}", host.trim_end_matches('/'), v.as_str().unwrap()));
+    }
 
     // read columns as array from input json and convert data type from Vec<Value> to Vec<String>
-    let maf_col:Vec<String>;
+    let maf_col: Vec<String>;
     if let Some(maf_col_value) = file_id_lst_js.get("columns") {
         //convert Vec<Value> to Vec<String>
         if let Some(maf_col_array) = maf_col_value.as_array() {
             maf_col = maf_col_array
                 .iter()
-                .map(|v| v.to_string().replace("\"",""))
+                .map(|v| v.to_string().replace("\"", ""))
                 .collect::<Vec<String>>();
         } else {
             let column_error = ErrorEntry {
@@ -165,62 +169,58 @@ async fn main() -> Result<(),Box<dyn std::error::Error>> {
         let column_error_js = serde_json::to_string(&column_error).unwrap();
         writeln!(io::stderr(), "{}", column_error_js).expect("Failed to output stderr!");
         return Err(Box::new(std::io::Error::new(
-                std::io::ErrorKind::InvalidInput,
-                "Columns was not selected",
+            std::io::ErrorKind::InvalidInput,
+            "Columns was not selected",
         )) as Box<dyn std::error::Error>);
     };
-    
+
     //downloading maf files parallelly and merge them into single maf file
-    let download_futures = futures::stream::iter(
-        url.into_iter().map(|url|{
-            async move {
-                let client = reqwest::Client::builder()
-                    .timeout(Duration::from_secs(60)) // 60-second timeout per request
-                    .connect_timeout(Duration::from_secs(15))
-                    .build()
-                    .map_err(|_e| {
-                        let client_error = ErrorEntry{
-                            url: url.clone(),
-                            error: "Client build error".to_string(),
-                        };
-                        let client_error_js = serde_json::to_string(&client_error).unwrap();
-                        writeln!(io::stderr(), "{}", client_error_js).expect("Failed to build reqwest client!");
-                    });
-                match client.unwrap().get(&url).send().await {
-                    Ok(resp) if resp.status().is_success() => {
-                        match resp.bytes().await {
-                            Ok(content) => {
-                                let mut decoder = GzDecoder::new(&content[..]);
-                                let mut decompressed_content = Vec::new();
-                                match decoder.read_to_end(&mut decompressed_content) {
-                                    Ok(_) => {
-                                        let text = String::from_utf8_lossy(&decompressed_content).to_string();
-                                        return Ok((url.clone(),text))
-                                    }
-                                    Err(e) => {
-                                        let error_msg = format!("Failed to decompress downloaded maf file: {}", e);
-                                        Err((url.clone(), error_msg))
-                                    }
-                                }
+    let download_futures = futures::stream::iter(url.into_iter().map(|url| {
+        async move {
+            let client = reqwest::Client::builder()
+                .timeout(Duration::from_secs(60)) // 60-second timeout per request
+                .connect_timeout(Duration::from_secs(15))
+                .build()
+                .map_err(|_e| {
+                    let client_error = ErrorEntry {
+                        url: url.clone(),
+                        error: "Client build error".to_string(),
+                    };
+                    let client_error_js = serde_json::to_string(&client_error).unwrap();
+                    writeln!(io::stderr(), "{}", client_error_js).expect("Failed to build reqwest client!");
+                });
+            match client.unwrap().get(&url).send().await {
+                Ok(resp) if resp.status().is_success() => match resp.bytes().await {
+                    Ok(content) => {
+                        let mut decoder = GzDecoder::new(&content[..]);
+                        let mut decompressed_content = Vec::new();
+                        match decoder.read_to_end(&mut decompressed_content) {
+                            Ok(_) => {
+                                let text = String::from_utf8_lossy(&decompressed_content).to_string();
+                                return Ok((url.clone(), text));
                             }
                             Err(e) => {
-                                let error_msg = format!("Failed to decompress downloaded maf file: {}", e);
+                                let error_msg = format!("Failed to decompress downloaded MAF file: {}", e);
                                 Err((url.clone(), error_msg))
                             }
                         }
                     }
-                    Ok(resp) => {
-                        let error_msg = format!("HTTP error: {}", resp.status());
-                        Err((url.clone(), error_msg))
-                    }
                     Err(e) => {
-                        let error_msg = format!("Server request failed: {}", e);
+                        let error_msg = format!("Failed to decompress downloaded MAF file: {}", e);
                         Err((url.clone(), error_msg))
                     }
+                },
+                Ok(resp) => {
+                    let error_msg = format!("HTTP error: {}", resp.status());
+                    Err((url.clone(), error_msg))
+                }
+                Err(e) => {
+                    let error_msg = format!("Server request failed: {}", e);
+                    Err((url.clone(), error_msg))
                 }
             }
-        })
-    );
+        }
+    }));
 
     // binary output
     let encoder = Arc::new(Mutex::new(GzEncoder::new(io::stdout(), Compression::default())));
@@ -228,57 +228,57 @@ async fn main() -> Result<(),Box<dyn std::error::Error>> {
     // Write the header
     {
         let mut encoder_guard = encoder.lock().unwrap(); // Lock the Mutex to get access to the inner GzEncoder
-        encoder_guard.write_all(&maf_col.join("\t").as_bytes().to_vec()).expect("Failed to write header");
+        encoder_guard
+            .write_all(&maf_col.join("\t").as_bytes().to_vec())
+            .expect("Failed to write header");
         encoder_guard.write_all(b"\n").expect("Failed to write newline");
     }
-    
-    download_futures.buffer_unordered(20).for_each( |result| {
-        let encoder = Arc::clone(&encoder); // Clone the Arc for each task
-        let maf_col_cp = maf_col.clone();
-        async move {
-            match result {
-                Ok((url, content)) => {
-                    match select_maf_col(content, &maf_col_cp, &url) {
-                        Ok((maf_bit,mafrows)) => {
+
+    download_futures
+        .buffer_unordered(20)
+        .for_each(|result| {
+            let encoder = Arc::clone(&encoder); // Clone the Arc for each task
+            let maf_col_cp = maf_col.clone();
+            async move {
+                match result {
+                    Ok((url, content)) => match select_maf_col(content, &maf_col_cp, &url) {
+                        Ok((maf_bit, mafrows)) => {
                             if mafrows > 0 {
                                 let mut encoder_guard = encoder.lock().unwrap();
                                 encoder_guard.write_all(&maf_bit).expect("Failed to write file");
                             } else {
                                 let error = ErrorEntry {
                                     url: url.clone(),
-                                    error: "Empty maf file".to_string(),
+                                    error: "Empty MAF file".to_string(),
                                 };
                                 let error_js = serde_json::to_string(&error).unwrap();
                                 writeln!(io::stderr(), "{}", error_js).expect("Failed to output stderr!");
                             }
                         }
-                        Err((url,error)) => {
-                            let error = ErrorEntry {
-                                url,
-                                error,
-                            };
+                        Err((url, error)) => {
+                            let error = ErrorEntry { url, error };
                             let error_js = serde_json::to_string(&error).unwrap();
                             writeln!(io::stderr(), "{}", error_js).expect("Failed to output stderr!");
                         }
+                    },
+                    Err((url, error)) => {
+                        let error = ErrorEntry { url, error };
+                        let error_js = serde_json::to_string(&error).unwrap();
+                        writeln!(io::stderr(), "{}", error_js).expect("Failed to output stderr!");
                     }
-                }
-                Err((url, error)) => {
-                    let error = ErrorEntry {
-                        url,
-                        error,
-                    };
-                    let error_js = serde_json::to_string(&error).unwrap();
-                    writeln!(io::stderr(), "{}", error_js).expect("Failed to output stderr!");
-                }
-            };
-        }
-    }).await;
-    
+                };
+            }
+        })
+        .await;
+
     // Finalize output
 
     // Replace the value inside the Mutex with a dummy value (e.g., None)
     let mut encoder_guard = encoder.lock().unwrap();
-    let encoder = std::mem::replace(&mut *encoder_guard, GzEncoder::new(io::stdout(), Compression::default()));
+    let encoder = std::mem::replace(
+        &mut *encoder_guard,
+        GzEncoder::new(io::stdout(), Compression::default()),
+    );
     // Finalize the encoder
     encoder.finish().expect("Maf file output error!");
 

package/src/genesetORA.rs

@@ -9,7 +9,7 @@ use serde_json;
 use std::cmp::Ordering;
 use std::collections::HashSet;
 use std::io;
-use std::time::Instant;
+//use std::time::Instant;
 
 #[allow(non_camel_case_types)]
 #[allow(non_snake_case)]
@@ -37,10 +37,7 @@ fn calculate_hypergeometric_p_value(
 ) -> (f64, f64, String) {
     let mut gene_set_hits: String = "".to_string();
 
-    let gene_intersections: HashSet<String> = genes_in_pathway
-        .intersection(sample_genes)
-        .cloned()
-        .collect();
+    let gene_intersections: HashSet<String> = genes_in_pathway.intersection(sample_genes).cloned().collect();
     for gene in &gene_intersections {
         gene_set_hits += &(gene.to_string() + &",");
     }
@@ -78,7 +75,7 @@ fn main() -> Result<()> {
             let input_json = json::parse(&input);
             match input_json {
                 Ok(json_string) => {
-                    let run_time = Instant::now();
+                    //let run_time = Instant::now();
                     let msigdb_input: &JsonValue = &json_string["msigdb"];
                     let msigdb;
                     match msigdb_input.as_str() {
@@ -92,8 +89,7 @@ fn main() -> Result<()> {
                         None => panic!("genesetgroup is missing"),
                     }
                     let sample_genes_input: &JsonValue = &json_string["sample_genes"];
-                    let sample_genes: Vec<&str> =
-                        sample_genes_input.as_str().unwrap().split(",").collect();
+                    let sample_genes: Vec<&str> = sample_genes_input.as_str().unwrap().split(",").collect();
                     let mut pathway_p_values: Vec<pathway_p_value> = Vec::with_capacity(10000);
 
                     let genedb_input: &JsonValue = &json_string["genedb"];
@@ -103,10 +99,8 @@ fn main() -> Result<()> {
                         None => panic!("genedb file path is missing"),
                     }
 
-                    let filter_non_coding_genes_input: &JsonValue =
-                        &json_string["filter_non_coding_genes"];
-                    let filter_non_coding_genes: bool =
-                        filter_non_coding_genes_input.as_bool().unwrap();
+                    let filter_non_coding_genes_input: &JsonValue = &json_string["filter_non_coding_genes"];
+                    let filter_non_coding_genes: bool = filter_non_coding_genes_input.as_bool().unwrap();
 
                     let genedbconn = Connection::open(genedb)?;
                     let genedb_result = genedbconn.prepare(&("select * from codingGenes"));
@@ -120,8 +114,7 @@ fn main() -> Result<()> {
                                 //println!("coding_gene:{:?}", coding_gene);
                                 for sample_gene in &sample_genes {
                                     let code_gene: String = coding_gene.get(0).unwrap();
-                                    if filter_non_coding_genes == true && code_gene == *sample_gene
-                                    {
+                                    if filter_non_coding_genes == true && code_gene == *sample_gene {
                                         sample_coding_genes.insert(code_gene);
                                     } else if filter_non_coding_genes == false {
                                         sample_coding_genes.insert(code_gene);
@@ -160,25 +153,19 @@ fn main() -> Result<()> {
                     let num_items_output = 100; // Number of top pathways to be specified in the output
 
                     let msigdbconn = Connection::open(msigdb)?;
-                    let stmt_result = msigdbconn.prepare(
-                        &("select id from terms where parent_id='".to_owned()
-                            + &genesetgroup
-                            + "'"),
-                    );
+                    let stmt_result = msigdbconn
+                        .prepare(&("select id from terms where parent_id='".to_owned() + &genesetgroup + "'"));
                     match stmt_result {
                         Ok(mut stmt) => {
                             #[allow(non_snake_case)]
-                            let GO_iter =
-                                stmt.query_map([], |row| Ok(GO_pathway { GO_id: row.get(0)? }))?;
+                            let GO_iter = stmt.query_map([], |row| Ok(GO_pathway { GO_id: row.get(0)? }))?;
                             #[allow(non_snake_case)]
                             for GO_term in GO_iter {
                                 match GO_term {
                                     Ok(n) => {
                                         //println!("GO term {:?}", n);
                                         let sql_statement =
-                                            "select genes from term2genes where id='".to_owned()
-                                                + &n.GO_id
-                                                + &"'";
+                                            "select genes from term2genes where id='".to_owned() + &n.GO_id + &"'";
                                         //println!("sql_statement:{}", sql_statement);
                                         let mut gene_stmt = msigdbconn.prepare(&(sql_statement))?;
                                         //println!("gene_stmt:{:?}", gene_stmt);
@@ -191,26 +178,20 @@ fn main() -> Result<()> {
                                             match input_gene_json {
                                                 Ok(json_genes) => {
                                                     for json_iter in 0..json_genes.len() {
-                                                        names.insert(
-                                                            json_genes[json_iter]["symbol"]
-                                                                .to_string(),
-                                                        );
+                                                        names.insert(json_genes[json_iter]["symbol"].to_string());
                                                     }
                                                 }
                                                 Err(_) => {
-                                                    panic!(
-                                                "Symbol, ensg, enstCanonical structure is missing!"
-                                            )
+                                                    panic!("Symbol, ensg, enstCanonical structure is missing!")
                                                 }
                                             }
                                         }
                                         let gene_set_size = names.len();
-                                        let (p_value, matches, gene_set_hits) =
-                                            calculate_hypergeometric_p_value(
-                                                &sample_coding_genes,
-                                                num_background_genes,
-                                                names,
-                                            );
+                                        let (p_value, matches, gene_set_hits) = calculate_hypergeometric_p_value(
+                                            &sample_coding_genes,
+                                            num_background_genes,
+                                            names,
+                                        );
                                         if matches >= 1.0 && p_value.is_nan() == false {
                                             pathway_p_values.push(pathway_p_value {
                                                 pathway_name: n.GO_id,
@@ -234,11 +215,8 @@ fn main() -> Result<()> {
                         + &",\"pathways\":"
                         + &adjust_p_values(pathway_p_values, num_items_output)
                         + &"}";
-                    println!("pathway_p_values:{}", output_string);
-                    println!(
-                        "Time for calculating gene overrepresentation:{:?}",
-                        run_time.elapsed()
-                    );
+                    println!("{}", output_string);
+                    //println!("Time for calculating gene overrepresentation:{:?}", run_time.elapsed());
                 }
                 Err(error) => println!("Incorrect json:{}", error),
             }
@@ -248,10 +226,7 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn adjust_p_values(
-    mut original_p_values: Vec<pathway_p_value>,
-    mut num_items_output: usize,
-) -> String {
+fn adjust_p_values(mut original_p_values: Vec<pathway_p_value>, mut num_items_output: usize) -> String {
     // Sorting p-values in ascending order
     original_p_values.as_mut_slice().sort_by(|a, b| {
         (a.p_value_original)
@@ -266,8 +241,7 @@ fn adjust_p_values(
         let i = original_p_values.len() - j - 1;
 
         //println!("p_val:{}", p_val);
-        let mut adjusted_p_val: f64 =
-            original_p_values[i].p_value_original * (original_p_values.len() as f64 / rank); // adjusted p-value = original_p_value * (N/rank)
+        let mut adjusted_p_val: f64 = original_p_values[i].p_value_original * (original_p_values.len() as f64 / rank); // adjusted p-value = original_p_value * (N/rank)
         if adjusted_p_val > 1.0 {
             // p_value should NEVER be greater than 1
             adjusted_p_val = 1.0;