@sjcrh/proteinpaint-rust 2.124.0 → 2.126.0

package/Cargo.toml

@@ -34,6 +34,7 @@ reqwest = "0.11"
 flate2 = "1"
 futures = "0.3" 
 num_cpus = "1.16.0"
+memchr = "2"
 
 [profile.release]
 lto = "fat"
@@ -100,3 +101,11 @@ path="src/readHDF5.rs"
 [[bin]]
 name="validateHDF5"
 path="src/validateHDF5.rs"
+
+[[bin]]
+name="gdcGRIN2"
+path="src/gdcGRIN2.rs"
+
+[[bin]]
+name="cerno"
+path="src/cerno.rs"

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.124.0",
+	"version": "2.126.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.124.0"
+	"pp_release_tag": "v2.126.0"
 }

package/src/cerno.rs

@@ -0,0 +1,341 @@
+// Syntax: cd .. && cargo build --release && time cat ~/sjpp/test.txt | target/release/cerno
+#![allow(non_snake_case)]
+use json::JsonValue;
+use r_mathlib::chi_squared_cdf;
+use rusqlite::{Connection, Result};
+use serde::{Deserialize, Serialize};
+use serde_json;
+use std::cmp::Ordering;
+use std::collections::HashSet;
+use std::io;
+
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[derive(Debug)]
+struct GO_pathway {
+    GO_id: String,
+}
+
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
+struct gene_order {
+    gene_name: String,
+    fold_change: f64,
+    rank: Option<usize>,
+}
+
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[derive(Debug, Serialize, Deserialize)]
+//#[allow(dead_code)]
+struct pathway_p_value {
+    pathway_name: String,
+    p_value_original: f64,
+    p_value_adjusted: Option<f64>,
+    gene_set_hits: String,
+    auc: f64,
+    es: f64,
+    gene_set_size: usize,
+}
+
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[derive(Debug, Serialize, Deserialize)]
+//#[allow(dead_code)]
+struct output_struct {
+    pval: f64,
+    fdr: f64,
+    leading_edge: String,
+    auc: f64,
+    es: f64,
+    geneset_size: usize,
+}
+
+fn main() -> Result<()> {
+    let mut input = String::new();
+    match io::stdin().read_line(&mut input) {
+        // Accepting the piped input from nodejs (or command line from testing)
+        Ok(_n) => {
+            let input_json = json::parse(&input);
+            match input_json {
+                Ok(json_string) => {
+                    let msigdb_input: &JsonValue = &json_string["db"];
+                    let msigdb;
+                    match msigdb_input.as_str() {
+                        Some(db_string) => msigdb = db_string.to_string(),
+                        None => panic!("msigdb file path is missing"),
+                    }
+                    let genesetgroup;
+                    let genesetgroup_input: &JsonValue = &json_string["geneset_group"];
+                    match genesetgroup_input.as_str() {
+                        Some(genesetgroup_string) => genesetgroup = genesetgroup_string.to_string(),
+                        None => panic!("genesetgroup is missing"),
+                    }
+                    let sample_genes_input: &JsonValue = &json_string["genes"];
+                    let mut sample_genes = Vec::<&str>::new();
+                    for iter in 0..sample_genes_input.len() {
+                        let item = sample_genes_input[iter].as_str().unwrap();
+                        sample_genes.push(item);
+                    }
+                    //println!("sample_genes:{:?}", sample_genes);
+
+                    let fold_change_input: &JsonValue = &json_string["fold_change"];
+                    let mut fold_change_f64 = Vec::<f64>::new();
+                    for iter in 0..fold_change_input.len() {
+                        let item = fold_change_input[iter].as_f64().unwrap();
+                        fold_change_f64.push(item);
+                    }
+
+                    if sample_genes.len() == 0 {
+                        panic!("No sample genes provided");
+                    }
+
+                    if sample_genes.len() != fold_change_f64.len() {
+                        panic!("Length of genes array and fold change array are not equal");
+                    }
+
+                    let mut genes_vector: Vec<gene_order> = Vec::with_capacity(sample_genes.len());
+                    for i in 0..sample_genes.len() {
+                        let item: gene_order = gene_order {
+                            gene_name: sample_genes[i].to_string(),
+                            fold_change: fold_change_f64[i],
+                            rank: None, // Will be calculated later
+                        };
+                        genes_vector.push(item)
+                    }
+                    let mut pathway_p_values: Vec<pathway_p_value> = Vec::with_capacity(10000);
+
+                    let genedb_input: &JsonValue = &json_string["genedb"];
+                    let genedb;
+                    match genedb_input.as_str() {
+                        Some(gene_db_string) => genedb = gene_db_string.to_string(),
+                        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 genedbconn = Connection::open(genedb)?;
+                    let genedb_result = genedbconn.prepare(&("select * from codingGenes"));
+                    let mut sample_coding_genes: Vec<gene_order> = Vec::with_capacity(24000);
+                    match genedb_result {
+                        Ok(mut x) => {
+                            let mut genes = x.query([])?;
+                            while let Some(coding_gene) = genes.next()? {
+                                //println!("coding_gene:{:?}", coding_gene);
+                                for sample_gene in &genes_vector {
+                                    let code_gene: String = coding_gene.get(0).unwrap();
+                                    if filter_non_coding_genes == true && code_gene == *sample_gene.gene_name {
+                                        sample_coding_genes.push(sample_gene.clone());
+                                    } else if filter_non_coding_genes == false {
+                                        sample_coding_genes.push(sample_gene.clone());
+                                    }
+                                }
+                            }
+                        }
+                        Err(_) => {}
+                    }
+
+                    if sample_coding_genes.len() == 0 {
+                        panic!("All query genes are non-coding");
+                    }
+
+                    // Sort sample_coding_gene in descending order
+                    sample_coding_genes
+                        .as_mut_slice()
+                        .sort_by(|a, b| (b.fold_change).partial_cmp(&a.fold_change).unwrap_or(Ordering::Equal));
+
+                    // Assign ranks to each gene
+                    for i in 0..sample_coding_genes.len() {
+                        sample_coding_genes[i].rank = Some(i)
+                    }
+
+                    //println!("sample_genes:{:?}", sample_genes);
+                    //println!("background_genes:{:?}", background_genes);
+
+                    let msigdbconn = Connection::open(msigdb)?;
+                    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)? }))?;
+                            #[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 + &"'";
+                                        //println!("sql_statement:{}", sql_statement);
+                                        let mut gene_stmt = msigdbconn.prepare(&(sql_statement))?;
+                                        //println!("gene_stmt:{:?}", gene_stmt);
+
+                                        let mut rows = gene_stmt.query([])?;
+                                        let mut names = HashSet::<String>::new();
+                                        while let Some(row) = rows.next()? {
+                                            let a: String = row.get(0)?;
+                                            let input_gene_json = json::parse(&a);
+                                            match input_gene_json {
+                                                Ok(json_genes) => {
+                                                    for json_iter in 0..json_genes.len() {
+                                                        names.insert(json_genes[json_iter]["symbol"].to_string());
+                                                    }
+                                                }
+                                                Err(_) => {
+                                                    panic!("Symbol, ensg, enstCanonical structure is missing!")
+                                                }
+                                            }
+                                        }
+                                        let gene_set_size = names.len();
+                                        let (p_value, auc, es, matches, gene_set_hits) =
+                                            cerno(&sample_coding_genes, names);
+
+                                        if matches >= 1.0
+                                            && p_value.is_nan() == false
+                                            && es.is_nan() == false
+                                            && es != f64::INFINITY
+                                            && auc != f64::INFINITY
+                                            && auc.is_nan() == false
+                                        {
+                                            pathway_p_values.push(pathway_p_value {
+                                                pathway_name: n.GO_id,
+                                                p_value_original: p_value,
+                                                p_value_adjusted: None,
+                                                auc: auc,
+                                                es: es,
+                                                gene_set_hits: gene_set_hits,
+                                                gene_set_size: gene_set_size,
+                                            })
+                                        }
+                                    }
+                                    Err(_) => {
+                                        println!("GO term not found!")
+                                    }
+                                }
+                            }
+                        }
+                        Err(_) => panic!("sqlite database file not found"),
+                    }
+                    let output_string =
+                        "result: {".to_string() + &"\"data\":" + &adjust_p_values(pathway_p_values) + &"}";
+                    println!("{}", output_string);
+                }
+                Err(error) => println!("Incorrect json:{}", error),
+            }
+        }
+        Err(error) => println!("Piping error: {}", error),
+    }
+    Ok(())
+}
+
+fn cerno(sample_coding_genes: &Vec<gene_order>, genes_in_pathway: HashSet<String>) -> (f64, f64, f64, f64, String) {
+    // Filter the sample_coding_genes vector to only include those whose gene_names are in the HashSet genes_in_pathway
+    let gene_intersections: Vec<&gene_order> = sample_coding_genes
+        .iter()
+        .filter(|sample_coding_genes| genes_in_pathway.contains(&sample_coding_genes.gene_name)) // Check if name is in the HashSet genes_in_pathway
+        .collect(); // Collect the results into a new vector
+
+    let N1 = gene_intersections.len() as f64;
+    let N = sample_coding_genes.len() as f64;
+    let mut gene_set_hits: String = "".to_string();
+    for gene in &gene_intersections {
+        gene_set_hits += &(gene.gene_name.to_string() + &",");
+    }
+    if gene_intersections.len() > 0 {
+        // Remove the last "," in string
+        gene_set_hits.pop();
+    }
+
+    let ranks: Vec<usize> = gene_intersections // x <- l %in% mset$gs2gv[[m]] ; ranks <- c(1:N)[x]
+        .iter()
+        .map(|x| x.rank.unwrap())
+        .collect::<Vec<usize>>();
+
+    let cerno: f64 = ranks // -2 * sum( log(ranks/N) )
+        .iter()
+        .map(|x| ((*x as f64) / N).ln())
+        .collect::<Vec<f64>>()
+        .iter()
+        .sum::<f64>()
+        * (-2.0);
+
+    let cES: f64 = cerno / (2.0 * (N1 as f64)); // cES <- cerno/(2*N1)
+    let N2 = N - N1; // N2 = N - N1
+    let R1 = ranks.iter().sum::<usize>() as f64; // R1 <- sum(ranks)
+    let U = N1 * N2 + N1 * (N1 + 1.0) / 2.0 - R1; // U  <- N1*N2+N1*(N1+1)/2-R1
+    let AUC = U / (N1 * N2); // AUC <- U/(N1*N2)
+    let p_value = chi_squared_cdf(cerno, 2.0 * N1, false, false); // pchisq(ret$cerno, 2*N1, lower.tail=FALSE)
+    (p_value, AUC, cES, N1, gene_set_hits)
+}
+
+fn adjust_p_values(mut original_p_values: Vec<pathway_p_value>) -> String {
+    // Sorting p-values in ascending order
+    original_p_values.as_mut_slice().sort_by(|a, b| {
+        (a.p_value_original)
+            .partial_cmp(&b.p_value_original)
+            .unwrap_or(Ordering::Equal)
+    });
+
+    let mut adjusted_p_values: Vec<pathway_p_value> = Vec::with_capacity(original_p_values.len());
+    let mut old_p_value: f64 = 0.0;
+    let mut rank: f64 = original_p_values.len() as f64;
+    for j in 0..original_p_values.len() {
+        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)
+        if adjusted_p_val > 1.0 {
+            // p_value should NEVER be greater than 1
+            adjusted_p_val = 1.0;
+        }
+        //println!("Original p_value:{}", original_p_values[i].p_value);
+        //println!("Raw adjusted p_value:{}", adjusted_p_value);
+        if i != original_p_values.len() - 1 {
+            if adjusted_p_val > old_p_value {
+                adjusted_p_val = old_p_value;
+            }
+        }
+        old_p_value = adjusted_p_val;
+        //println!("adjusted_p_value:{}", adjusted_p_val);
+        rank -= 1.0;
+
+        adjusted_p_values.push(pathway_p_value {
+            pathway_name: original_p_values[i].pathway_name.clone(),
+            p_value_original: original_p_values[i].p_value_original,
+            p_value_adjusted: Some(adjusted_p_val),
+            auc: original_p_values[i].auc,
+            es: original_p_values[i].es,
+            gene_set_hits: original_p_values[i].gene_set_hits.clone(),
+            gene_set_size: original_p_values[i].gene_set_size,
+        });
+    }
+    adjusted_p_values.as_mut_slice().sort_by(|a, b| {
+        (a.p_value_adjusted.unwrap())
+            .partial_cmp(&b.p_value_adjusted.unwrap())
+            .unwrap_or(Ordering::Equal)
+    });
+
+    let mut output_string = "{".to_string();
+    for i in 0..adjusted_p_values.len() {
+        let item = output_struct {
+            pval: adjusted_p_values[i].p_value_original,
+            fdr: adjusted_p_values[i].p_value_adjusted.unwrap(),
+            leading_edge: adjusted_p_values[i].gene_set_hits.clone(),
+            geneset_size: adjusted_p_values[i].gene_set_size,
+            es: adjusted_p_values[i].es,
+            auc: adjusted_p_values[i].auc,
+        };
+        output_string += &format!(
+            "\"{}\":{}",
+            adjusted_p_values[i].pathway_name.clone(),
+            serde_json::to_string(&item).unwrap()
+        );
+        if i < adjusted_p_values.len() - 1 {
+            output_string += &",".to_string();
+        }
+    }
+    output_string += &"}".to_string();
+    output_string
+}

package/src/gdcGRIN2.rs

@@ -0,0 +1,295 @@
+use flate2::read::GzDecoder;
+use futures::StreamExt;
+use memchr::memchr;
+use serde::Deserialize;
+use serde_json;
+use std::collections::HashMap;
+use std::io::{self, Read, Write};
+use std::time::Duration;
+use tokio::io::{AsyncReadExt, BufReader};
+use tokio::time::timeout;
+
+// Struct to hold error information
+#[derive(serde::Serialize)]
+struct ErrorEntry {
+    case: String,
+    error: String,
+}
+
+// Define the structure for datadd
+#[derive(Deserialize, Debug)]
+struct DataType {
+    cnv: Option<String>,
+    maf: Option<String>,
+}
+
+// Function to parse TSV content
+// CNV:
+// Select cnv columns ["Chromosome","Start","End","Segment_Mean"]
+// Segment_Mean >= 0.2 => gain; Segment_Mean <= -0.2 => loss
+// MAF:
+// Select MAF columns ["Chromosome","Start_Position","End_Position"]
+fn parse_content(content: &str, case_id: &str, data_type: &str) -> Result<String, (String, String, String)> {
+    let lines = content.lines();
+    //let mut parsed_data = Vec::new();
+    let mut parsed_data: String = String::new();
+    let mut columns_indices: Vec<usize> = Vec::new();
+    let mut header_mk: &str = "";
+    let mut columns = Vec::new(); // columns selected from GDC file
+    if data_type == "cnv" {
+        header_mk = "GDC_Aliquot_ID";
+        columns = vec!["Chromosome", "Start", "End", "Segment_Mean"]
+    } else if data_type == "maf" {
+        header_mk = "Hugo_Symbol";
+        columns = vec!["Chromosome", "Start_Position", "End_Position"]
+    };
+    let mut header: Vec<String> = Vec::new(); // GDC file header
+    for line in lines {
+        if line.starts_with("#") {
+            continue;
+        } else if line.contains(&header_mk) {
+            // header line
+            header = line.split("\t").map(|s| s.to_string()).collect();
+            for col in &columns {
+                match header.iter().position(|x| x == col) {
+                    Some(index) => {
+                        columns_indices.push(index);
+                    }
+                    None => {
+                        let error_msg = format!("Column {} was not found", col);
+                        return Err((case_id.to_string(), data_type.to_string(), error_msg));
+                    }
+                }
+            }
+        } else {
+            let mut keep_ck: bool = true;
+            let cont_lst: Vec<String> = line.split("\t").map(|s| s.to_string()).collect();
+            let mut out_lst: Vec<String> = Vec::new();
+            // add sample ID first
+            out_lst.push(case_id.to_string());
+            for x in columns_indices.iter() {
+                let mut element = cont_lst[*x].to_string();
+                if data_type == "cnv" && &header[*x] == "Segment_Mean" {
+                    // convert to f32 (segment_mean)
+                    let seg_mean = match element.parse::<f32>() {
+                        Ok(val) => val,
+                        Err(_e) => {
+                            let error_msg = "Segment_Mean in cnv file is not float".to_string();
+                            return Err((case_id.to_string(), data_type.to_string(), error_msg));
+                        }
+                    };
+                    if seg_mean >= 0.2 {
+                        element = "gain".to_string();
+                    } else if seg_mean <= -0.2 {
+                        element = "loss".to_string();
+                    } else {
+                        keep_ck = false;
+                    }
+                }
+                out_lst.push(element);
+            }
+            // add lsn.type to snv
+            if data_type == "maf" {
+                out_lst.push("mutation".to_string());
+            }
+            if keep_ck {
+                parsed_data.push_str(out_lst.join("\t").as_str());
+                parsed_data.push_str("\n");
+            }
+        }
+    }
+    if columns_indices.is_empty() {
+        return Err((
+            case_id.to_string(),
+            data_type.to_string(),
+            "No matching columns found. Problematic file!".to_string(),
+        ));
+    };
+    Ok(parsed_data)
+}
+
+// Function to download data
+//async fn download_data(data4dl: HashMap<String,DataType>, host: &str) -> Vec<Result<(String, String), (String, String)>> {
+async fn download_data(data4dl: HashMap<String, DataType>, host: &str) -> () {
+    // Generate URLs from data4dl, handling optional cnv and maf
+    let data_urls = data4dl
+        .into_iter()
+        .flat_map(|(case_id, data_types)| {
+            let mut urls = Vec::new();
+            if let Some(cnv_uuid) = &data_types.cnv {
+                urls.push((case_id.clone(), "cnv".to_string(), format!("{}{}", host, cnv_uuid)));
+            }
+            if let Some(maf_uuid) = &data_types.maf {
+                urls.push((case_id.clone(), "maf".to_string(), format!("{}{}", host, maf_uuid)));
+            }
+            urls
+        })
+        .collect::<Vec<_>>();
+    let download_futures = futures::stream::iter(data_urls.into_iter().map(|(case_id, data_type, url)| {
+        async move {
+            //let case_dt = format!("{}/{}",case_id,data_type).to_string();
+            // Build HTTP client with timeouts
+            let client = reqwest::Client::builder()
+                .timeout(Duration::from_secs(60)) // 60-second timeout per request
+                .connect_timeout(Duration::from_secs(30))
+                .build()
+                .map_err(|_e| "Client build error".to_string());
+            // Handle client creation result
+            match client {
+                Ok(client) => {
+                    match client.get(&url).send().await {
+                        Ok(resp) if resp.status().is_success() => {
+                            match resp.bytes().await {
+                                Ok(content) => {
+                                    // if data_type == "cnv" {
+                                    if !memchr(0x00, &content).is_some() {
+                                        // CNV files are plain text
+                                        let text = String::from_utf8_lossy(&content).to_string();
+                                        Ok((case_id.clone(), data_type.clone(), text))
+                                    } else {
+                                        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();
+                                                Ok((case_id.clone(), data_type.clone(), text))
+                                            }
+                                            Err(e) => {
+                                                let error_msg = format!(
+                                                    "Failed to decompress {} file for {}: {}",
+                                                    data_type, case_id, e
+                                                );
+                                                Err((case_id.clone(), data_type.clone(), error_msg))
+                                            }
+                                        }
+                                    }
+                                }
+                                Err(e) => {
+                                    let error_msg =
+                                        format!("Failed to read bytes for {} file for {}: {}", data_type, case_id, e);
+                                    Err((case_id.clone(), data_type.clone(), error_msg))
+                                }
+                            }
+                        }
+                        Ok(resp) => {
+                            let error_msg =
+                                format!("HTTP error for {} file for {}: {}", data_type, case_id, resp.status());
+                            Err((case_id.clone(), data_type.clone(), error_msg))
+                        }
+                        Err(e) => {
+                            let error_msg =
+                                format!("Server request failed for {} file for {}: {}", data_type, case_id, e);
+                            Err((case_id.clone(), data_type.clone(), error_msg))
+                        }
+                    }
+                }
+                Err(_e) => {
+                    let error_msg = "Client build error".to_string();
+                    Err((case_id, data_type, error_msg))
+                }
+            }
+        }
+    }));
+
+    // Execute downloads concurrently and collect results
+    download_futures
+        .buffer_unordered(10)
+        .for_each(|result| async {
+            match result {
+                Ok((case_id, data_type, content)) => match parse_content(&content, &case_id, &data_type) {
+                    Ok(parsed_data) => match serde_json::to_string(&parsed_data) {
+                        Ok(json) => println!("{}", json),
+                        Err(e) => {
+                            let error = ErrorEntry {
+                                case: format!("{}: {}", case_id, data_type),
+                                error: format!("Failed to convert data to JSON {}", e),
+                            };
+                            let error_js = serde_json::to_string(&error).unwrap();
+                            eprintln!("{}", error_js);
+                        }
+                    },
+                    Err((cid, dtp, error)) => {
+                        let error = ErrorEntry {
+                            case: format!("{}: {}", cid, dtp),
+                            error,
+                        };
+                        let error_js = serde_json::to_string(&error).unwrap();
+                        eprintln!("{}", error_js);
+                    }
+                },
+                Err((case_id, data_type, error)) => {
+                    let error = ErrorEntry {
+                        case: format!("{}: {}", case_id, data_type),
+                        error,
+                    };
+                    let error_js = serde_json::to_string(&error).unwrap();
+                    eprintln!("{}", error_js);
+                }
+            }
+        })
+        .await;
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    const HOST: &str = "https://api.gdc.cancer.gov/data/";
+
+    // Accepting the piped input json from nodejs
+    let timeout_duration = Duration::from_secs(5); // Set a 5-second timeout
+
+    // Wrap the read operation in a timeout
+    let result = timeout(timeout_duration, async {
+        let mut buffer = String::new(); // Initialize an empty string to store input
+        let mut reader = BufReader::new(tokio::io::stdin()); // Create a buffered reader for stdin 
+        reader.read_to_string(&mut buffer).await?; // Read a line asynchronously
+        Ok::<String, io::Error>(buffer) // Return the input as a Result
+    })
+    .await;
+
+    // Handle the result of the input timeout operation
+    let input_js: HashMap<String, DataType> = match result {
+        Ok(Ok(buffer)) => match serde_json::from_str(&buffer) {
+            Ok(js) => js,
+            Err(e) => {
+                let stdin_error = ErrorEntry {
+                    case: String::new(),
+                    error: format!("Input 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,
+                    "Input JSON parsing Error!",
+                )) as Box<dyn std::error::Error>);
+            }
+        },
+        Ok(Err(_e)) => {
+            let stdin_error = ErrorEntry {
+                case: String::new(),
+                error: "Error reading from stdin.".to_string(),
+            };
+            let stdin_error_js = serde_json::to_string(&stdin_error).unwrap();
+            writeln!(io::stderr(), "{}", stdin_error_js).expect("Failed to output stderr!");
+            return Err(Box::new(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "Error reading from stdin!",
+            )) as Box<dyn std::error::Error>);
+        }
+        Err(_) => {
+            let stdin_error = ErrorEntry {
+                case: String::new(),
+                error: "Timeout while reading from stdin.".to_string(),
+            };
+            let stdin_error_js = serde_json::to_string(&stdin_error).unwrap();
+            writeln!(io::stderr(), "{}", stdin_error_js).expect("Failed to output stderr!");
+            return Err(Box::new(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "Timeout while reading from stdin.",
+            )) as Box<dyn std::error::Error>);
+        }
+    };
+
+    // Download data
+    download_data(input_js, HOST).await;
+
+    Ok(())
+}

package/src/readHDF5.rs

@@ -19,9 +19,9 @@
 use hdf5::types::{FixedAscii, VarLenAscii};
 use hdf5::{File, Result};
 use ndarray::Dim;
-use ndarray::{Array1, s};
+use ndarray::{s, Array1};
 use rayon::prelude::*;
-use serde_json::{Map, Value, json};
+use serde_json::{json, Map, Value};
 use std::io;
 use std::sync::Arc;
 use std::time::Instant;

package/src/test.rs

@@ -1,3 +0,0 @@
-fn main() {
-    println!("Hello, world!");
-}