@sjcrh/proteinpaint-rust 2.123.0 → 2.125.0

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.123.0",
+	"version": "2.125.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.123.0"
+	"pp_release_tag": "v2.125.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;

package/src/readHDF5.rs

@@ -1,9 +1,9 @@
 //------------------------------------------------------------------------------
 // readHDF5.rs - HDF5 Gene Expression Data Reader
 //------------------------------------------------------------------------------
-// 
+//
 // Extracts gene expression values from HDF5 files in dense or sparse formats.
-// Supports single genes with memory optimization and multiple genes with 
+// Supports single genes with memory optimization and multiple genes with
 // parallel processing.
 //
 // Features:
@@ -12,16 +12,16 @@
 // - Parallel processing for multiple genes
 // - JSON output with timing metrics
 //
-// Usage: 
-//   HDF5_DIR=/usr/local/Homebrew/Cellar/hdf5/1.14.3_1 && 
+// Usage:
+//   HDF5_DIR=/usr/local/Homebrew/Cellar/hdf5/1.14.3_1 &&
 //   echo $json='{"gene":"TP53","hdf5_file":"matrix.h5"}' | target/release/readHDF5
 //------------------------------------------------------------------------------
-use rayon::prelude::*;
 use hdf5::types::{FixedAscii, VarLenAscii};
 use hdf5::{File, Result};
 use ndarray::Dim;
-use ndarray::{Array1, s};
-use serde_json::{Map, Value, json};
+use ndarray::{s, Array1};
+use rayon::prelude::*;
+use serde_json::{json, Map, Value};
 use std::io;
 use std::sync::Arc;
 use std::time::Instant;
@@ -259,11 +259,7 @@ fn query_gene_dense(hdf5_filename: String, gene_name: String) -> Result<()> {
                     // Create direct key-value pairs where sample names are the keys
                     for i in 0..gene_expression.len() {
                         // Add each sample name as a key pointing directly to its expression value
-                        output_string += &format!(
-                            "\"{}\":{}",
-                            samples[i].to_string(),
-                            gene_expression[i].to_string()
-                        );
+                        output_string += &format!("\"{}\":{}", samples[i].to_string(), gene_expression[i].to_string());
 
                         // Add comma if not the last item
                         if i < gene_expression.len() - 1 {
@@ -296,10 +292,7 @@ fn query_gene_dense(hdf5_filename: String, gene_name: String) -> Result<()> {
                 Value::Null
             };
 
-            samples_map.insert(
-                sample.replace("\\", ""), 
-                value,
-            );
+            samples_map.insert(sample.replace("\\", ""), value);
         }
     }
 
@@ -317,7 +310,7 @@ fn query_gene_dense(hdf5_filename: String, gene_name: String) -> Result<()> {
 
 /// Reads expression data for a specific gene from a sparse format HDF5 file
 ///
-/// Extracts expression values from sparse matrix HDF5 files using Compressed 
+/// Extracts expression values from sparse matrix HDF5 files using Compressed
 /// Sparse Column (CSC) structure.
 ///
 /// # Arguments
@@ -391,15 +384,13 @@ fn query_gene_sparse(hdf5_filename: String, gene_name: String) -> Result<()> {
     // Find all columns indices that are populated for the given gene
     let now_i = Instant::now();
     let ds_i = file.dataset("data/i")?;
-    let populated_column_ids: Array1<usize> =
-        ds_i.read_slice_1d(array_start_point..array_stop_point)?;
+    let populated_column_ids: Array1<usize> = ds_i.read_slice_1d(array_start_point..array_stop_point)?;
     println!("Time for i dataset:{:?}", now_i.elapsed());
 
     // Find all columns values that are populated for the given gene
     let now_x = Instant::now();
     let ds_x = file.dataset("data/x")?;
-    let populated_column_values: Array1<f64> =
-        ds_x.read_slice_1d(array_start_point..array_stop_point)?;
+    let populated_column_values: Array1<f64> = ds_x.read_slice_1d(array_start_point..array_stop_point)?;
     println!("Time for x dataset:{:?}", now_x.elapsed());
 
     // Generate the complete array from the sparse array
@@ -425,10 +416,7 @@ fn query_gene_sparse(hdf5_filename: String, gene_name: String) -> Result<()> {
     }
     output_string += &"}".to_string();
 
-    println!(
-        "Time generating full array:{:?}",
-        time_generating_full_array.elapsed()
-    );
+    println!("Time generating full array:{:?}", time_generating_full_array.elapsed());
     println!("output_string:{}", output_string);
 
     Ok(())
@@ -465,7 +453,6 @@ fn query_multiple_genes_dense(hdf5_filename: String, gene_names: Vec<String>) ->
         }
     };
 
-
     let genes_dataset = match file.dataset("gene_ids") {
         Ok(ds) => ds,
         Err(err) => {
@@ -495,7 +482,7 @@ fn query_multiple_genes_dense(hdf5_filename: String, gene_names: Vec<String>) ->
     };
 
     let genes: Vec<String> = genes_varlen.iter().map(|g| g.to_string()).collect();
-    
+
     // Only create HashMap for multiple gene queries
     let gene_to_index: Option<std::collections::HashMap<String, usize>> = if gene_names.len() > 1 {
         let hashmap_start_time = Instant::now();
@@ -504,8 +491,8 @@ fn query_multiple_genes_dense(hdf5_filename: String, gene_names: Vec<String>) ->
             map.insert(gene.clone(), idx);
         }
         timings.insert(
-            "build_hashmap_ms".to_string(), 
-            Value::from(hashmap_start_time.elapsed().as_millis() as u64)
+            "build_hashmap_ms".to_string(),
+            Value::from(hashmap_start_time.elapsed().as_millis() as u64),
         );
         Some(map)
     } else {
@@ -586,14 +573,11 @@ fn query_multiple_genes_dense(hdf5_filename: String, gene_names: Vec<String>) ->
         };
 
         // Configurable thread count for testing
-        let thread_count = 2; 
+        let thread_count = 2;
         timings.insert("thread_count".to_string(), Value::from(thread_count));
 
         // Create a scoped thread pool with specified number of threads
-        match rayon::ThreadPoolBuilder::new()
-            .num_threads(thread_count)
-            .build()
-        {
+        match rayon::ThreadPoolBuilder::new().num_threads(thread_count).build() {
             Ok(pool) => {
                 // Use the pool for this specific work
                 pool.install(|| {
@@ -650,26 +634,20 @@ fn query_multiple_genes_dense(hdf5_filename: String, gene_names: Vec<String>) ->
                                         genes_map.insert(gene_name.clone(), gene_data);
                                     } else {
                                         // Fallback to per-gene reading if bulk load failed
-                                        match counts_dataset
-                                            .read_slice_1d::<f64, _>(s![gene_index, ..])
-                                        {
+                                        match counts_dataset.read_slice_1d::<f64, _>(s![gene_index, ..]) {
                                             Ok(gene_expression) => {
                                                 // Create samples map for this gene
                                                 let mut samples_map = Map::new();
                                                 for (i, sample) in samples.iter().enumerate() {
                                                     if i < gene_expression.len() {
                                                         // Handle potential NaN or infinity values
-                                                        let value =
-                                                            if gene_expression[i].is_finite() {
-                                                                Value::from(gene_expression[i])
-                                                            } else {
-                                                                Value::Null
-                                                            };
-
-                                                        samples_map.insert(
-                                                            sample.replace("\\", ""),
-                                                            value,
-                                                        );
+                                                        let value = if gene_expression[i].is_finite() {
+                                                            Value::from(gene_expression[i])
+                                                        } else {
+                                                            Value::Null
+                                                        };
+
+                                                        samples_map.insert(sample.replace("\\", ""), value);
                                                     }
                                                 }
 
@@ -693,10 +671,7 @@ fn query_multiple_genes_dense(hdf5_filename: String, gene_names: Vec<String>) ->
                                                 );
 
                                                 let mut genes_map = genes_map.lock().unwrap();
-                                                genes_map.insert(
-                                                    gene_name.clone(),
-                                                    Value::Object(error_map),
-                                                );
+                                                genes_map.insert(gene_name.clone(), Value::Object(error_map));
                                             }
                                         }
                                     }
@@ -736,7 +711,7 @@ fn query_multiple_genes_dense(hdf5_filename: String, gene_names: Vec<String>) ->
                     &counts_dataset,
                     &all_gene_data,
                     &samples,
-                    &genes_map
+                    &genes_map,
                 );
             }
         }
@@ -758,7 +733,6 @@ fn query_multiple_genes_dense(hdf5_filename: String, gene_names: Vec<String>) ->
                     // Read just this single gene's data directly
                     match counts_dataset.read_slice_1d::<f64, _>(s![gene_index, ..]) {
                         Ok(gene_expression) => {
-
                             // Create samples map for this gene
                             let mut samples_map = Map::new();
                             for (i, sample) in samples.iter().enumerate() {
@@ -786,10 +760,7 @@ fn query_multiple_genes_dense(hdf5_filename: String, gene_names: Vec<String>) ->
                             let mut error_map = Map::new();
                             error_map.insert(
                                 "error".to_string(),
-                                Value::String(format!(
-                                    "Failed to read expression values: {:?}",
-                                    err
-                                )),
+                                Value::String(format!("Failed to read expression values: {:?}", err)),
                             );
 
                             let mut genes_map = genes_map.lock().unwrap();
@@ -833,7 +804,7 @@ fn process_genes_sequentially(
     counts_dataset: &hdf5::Dataset,
     all_gene_data: &Option<ndarray::ArrayBase<ndarray::OwnedRepr<f64>, ndarray::Dim<[usize; 2]>>>,
     samples: &Vec<String>,
-    genes_map: &Arc<std::sync::Mutex<Map<String, Value>>>
+    genes_map: &Arc<std::sync::Mutex<Map<String, Value>>>,
 ) {
     for gene_name in gene_names {
         // Find the index of the requested gene, using HashMap if available
@@ -911,10 +882,7 @@ fn process_genes_sequentially(
                                 let mut error_map = Map::new();
                                 error_map.insert(
                                     "error".to_string(),
-                                    Value::String(format!(
-                                        "Failed to read expression values: {:?}",
-                                        err1
-                                    )),
+                                    Value::String(format!("Failed to read expression values: {:?}", err1)),
                                 );
 
                                 let mut genes_map = genes_map.lock().unwrap();
@@ -935,7 +903,6 @@ fn process_genes_sequentially(
                 genes_map.insert(gene_name.clone(), Value::Object(error_map));
             }
         }
-
     }
 }
 /// Queries expression data for multiple genes from a sparse format HDF5 file
@@ -1006,7 +973,6 @@ fn query_multiple_genes_sparse(hdf5_filename: String, gene_names: Vec<String>) -
     let num_threads = num_cpus::get();
     timings.insert("num_threads".to_string(), Value::from(num_threads as u64));
 
-
     // Thread-safe maps for results
     let genes_map = Arc::new(std::sync::Mutex::new(Map::new()));
     let gene_timings = Arc::new(std::sync::Mutex::new(Map::new()));
@@ -1041,8 +1007,7 @@ fn query_multiple_genes_sparse(hdf5_filename: String, gene_names: Vec<String>) -
                     // Read data for this gene
                     match ds_i.read_slice_1d::<usize, _>(array_start_point..array_stop_point) {
                         Ok(populated_column_ids) => {
-                            match ds_x.read_slice_1d::<f64, _>(array_start_point..array_stop_point)
-                            {
+                            match ds_x.read_slice_1d::<f64, _>(array_start_point..array_stop_point) {
                                 Ok(populated_column_values) => {
                                     // Generate the complete array from sparse representation
                                     let mut gene_array: Array1<f64> = Array1::zeros(num_samples);
@@ -1061,8 +1026,7 @@ fn query_multiple_genes_sparse(hdf5_filename: String, gene_names: Vec<String>) -
                                             Value::Null
                                         };
 
-                                        samples_map
-                                            .insert(sample.to_string().replace("\\", ""), value);
+                                        samples_map.insert(sample.to_string().replace("\\", ""), value);
                                     }
 
                                     let gene_data = json!({
@@ -1077,10 +1041,7 @@ fn query_multiple_genes_sparse(hdf5_filename: String, gene_names: Vec<String>) -
                                     let mut error_map = Map::new();
                                     error_map.insert(
                                         "error".to_string(),
-                                        Value::String(format!(
-                                            "Failed to read x dataset: {:?}",
-                                            err
-                                        )),
+                                        Value::String(format!("Failed to read x dataset: {:?}", err)),
                                     );
 
                                     let mut genes_map = genes_map.lock().unwrap();

package/src/validateHDF5.rs

@@ -6,7 +6,6 @@ use hdf5::{File, Result};
 use ndarray::Array1;
 use ndarray::Dim;
 use std::io;
-use serde_json;
 
 /// Detects the format of the HDF5 file
 pub fn detect_hdf5_format(hdf5_filename: &str) -> Result<&'static str> {