@sjcrh/proteinpaint-rust 2.58.0 → 2.60.0

package/downloadBinariesOrCompileSource.js

@@ -0,0 +1,119 @@
+const https = require('https')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { exec } = require('child_process')
+const tar = require('tar')
+
+// Read package.json to get version and pp_release_tag
+const packageJson = require(path.join(__dirname, 'package.json'))
+const { version, pp_release_tag } = packageJson
+
+const targetDirectory = './target/release'
+
+function downloadBinary(url, outputPath) {
+	const file = fs.createWriteStream(outputPath)
+	https
+		.get(url, function (response) {
+			if (response.statusCode >= 200 && response.statusCode <= 299) {
+				response.pipe(file)
+				file.on('finish', function () {
+					file.close()
+					console.log('Pre-compiled binaries download completed.')
+					extractAndClean(outputPath)
+				})
+			} else if (response.statusCode >= 300 && response.statusCode <= 399) {
+				if (response.headers.location) {
+					downloadBinary(response.headers.location, outputPath)
+				} else {
+					console.error('Redirection without location header encountered.')
+					compileFromSource()
+				}
+			} else {
+				console.error('Failed to download the binary. Compiling from source...')
+				compileFromSource()
+			}
+		})
+		.on('error', function (err) {
+			console.error('Error downloading the file:', err.message)
+			compileFromSource()
+		})
+}
+
+function compileFromSource() {
+	console.log('Starting compilation from source...')
+	const compileProcess = exec('cargo build --release', { cwd: path.join(__dirname) })
+
+	compileProcess.stdout.on('data', data => {
+		console.log(data.toString()) // Print standard output from cargo to console
+	})
+
+	compileProcess.stderr.on('data', data => {
+		console.error(data.toString()) // Print standard error from cargo to console as error
+	})
+
+	compileProcess.on('exit', code => {
+		if (code === 0) {
+			console.log('Compilation successful.')
+		} else {
+			console.error(`Compilation failed with exit code ${code}`)
+		}
+	})
+}
+
+function extractAndClean(tarPath) {
+	// Ensure target directory exists
+	fs.mkdirSync(targetDirectory, { recursive: true })
+
+	// Extract tar.gz file to target/release directory
+	tar
+		.x({
+			file: tarPath,
+			cwd: targetDirectory // Change directory to target/release
+		})
+		.then(() => {
+			console.log('Extraction complete.')
+			makeBinariesExecutable()
+			// Remove the tar file after successful extraction
+			fs.unlink(tarPath, err => {
+				if (err) {
+					console.error('Error removing the tar file:', err)
+				} else {
+					console.log('Tar file removed.')
+				}
+			})
+		})
+		.catch(err => {
+			console.error('Error during extraction:', err)
+		})
+}
+
+function makeBinariesExecutable() {
+	// Construct the full path to the directory
+	const fullPath = path.join(__dirname, targetDirectory)
+	const command = `chmod -R +x ${fullPath}`
+
+	exec(command, (error, stdout, stderr) => {
+		if (error) {
+			console.error(`Error setting executable permissions: ${error.message}`)
+			return
+		}
+		if (stderr) {
+			console.error(`Error output from chmod: ${stderr}`)
+			return
+		}
+		console.log(`Set executable permissions for all files in ${fullPath}`)
+	})
+}
+
+const architecture = os.arch()
+let binaryUrl = ''
+
+if (architecture === 'x64') {
+	binaryUrl = `https://github.com/stjude/proteinpaint/releases/download/${pp_release_tag}/rust-binaries-${version}-linux-x64.tar.gz`
+	const outputPath = path.join(__dirname, 'binaries.tar.gz')
+	downloadBinary(binaryUrl, outputPath)
+} else {
+	console.log('Unsupported architecture, attempting to compile from source...')
+	compileFromSource()
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.58.0",
+	"version": "2.60.0",
 	"name": "@sjcrh/proteinpaint-rust",
 	"description": "Rust-based utilities for proteinpaint",
 	"main": "index.js",
@@ -9,7 +9,7 @@
 	"scripts": {
 		"dev": "cargo build --release",
 		"build": "cargo build --release",
-		"postinstall": "if [ ! -d ./test ] & [ ! -d ./target/release ]; then cargo build --release; fi",
+		"postinstall": "if [ ! -d ./test ] & [ ! -d ./target/release ]; then node ./downloadBinariesOrCompileSource.js; fi",
 		"test": "tape **/test/*.spec.js",
 		"test:unit": "tape **/test/*.unit.spec.js",
 		"test:integration": "echo 'TODO: rust integration tests'"
@@ -25,13 +25,18 @@
 		"index.js",
 		"Cargo.toml",
 		"src",
+		"downloadBinariesOrCompileSource.js",
 		"LICENSE/*"
 	],
 	"bugs": {
 		"url": "https://github.com/stjude/proteinpaint"
 	},
 	"homepage": "https://github.com/stjude/proteinpaint#readme",
+	"dependencies": {
+		"tar": "^7.1.0"
+	},
 	"devDependencies": {
 		"tape": "^5.2.2"
-	}
+	},
+	"pp_release_tag": "v2.60.0"
 }

package/src/DEanalysis.rs

@@ -1,4 +1,4 @@
-// cd .. && cargo build --release && json='{"case":"SJMB030827,SJMB030838,SJMB032893,SJMB031131,SJMB031227","control":"SJMB030488,SJMB030825,SJMB031110","input_file":"/Users/rpaul1/pp_data/files/hg38/sjmb12/rnaseq/geneCounts.txt"}' && time echo $json | target/release/DEanalysis
+// cd .. && cargo build --release && json='{"min_count":10,"min_total_count":15,"case":"SJMB030827,SJMB030838,SJMB032893,SJMB031131,SJMB031227","control":"SJMB030488,SJMB030825,SJMB031110","input_file":"/Users/rpaul1/pp_data/files/hg38/sjmb12/rnaseq/geneCounts.txt"}' && time echo $json | target/release/DEanalysis
 // cd .. && cargo build --release && time cat ~/sjpp/test.txt | target/release/DEanalysis
 #![allow(non_snake_case)]
 use json;
@@ -368,6 +368,22 @@ fn main() {
             match input_json {
                 Ok(json_string) => {
                     let now = Instant::now();
+                    let min_count_option = json_string["min_count"].as_f64().to_owned();
+                    let min_total_count_option = json_string["min_total_count"].as_f64().to_owned();
+                    let min_count;
+                    match min_count_option {
+                        Some(x) => min_count = x,
+                        None => {
+                            panic!("min_count is missing a value")
+                        }
+                    }
+                    let min_total_count;
+                    match min_total_count_option {
+                        Some(x) => min_total_count = x,
+                        None => {
+                            panic!("min_total_count is missing a value")
+                        }
+                    }
                     let case_string = &json_string["case"].to_owned().as_str().unwrap().to_string();
                     let control_string = &json_string["control"]
                         .to_owned()
@@ -388,6 +404,8 @@ fn main() {
                     let filtering_time = Instant::now();
                     let (filtered_matrix, lib_sizes, filtered_genes, filtered_gene_symbols) =
                         filter_by_expr(
+                            min_count,
+                            min_total_count,
                             &input_matrix,
                             case_indexes.len(),
                             control_indexes.len(),
@@ -671,6 +689,7 @@ fn adjust_p_values_bonferroni(original_p_values: Vec<PValueIndexes>) -> Vec<Adju
     adjusted_p_values
 }
 
+// Original TMM normalization source code in edgeR: https://rdrr.io/bioc/edgeR/src/R/calcNormFactors.R
 fn tmm_normalization(
     input_matrix: Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>,
     lib_sizes: &Vec<f64>,
@@ -947,7 +966,10 @@ fn calc_quantile(mut input: Vec<f64>, p: f64) -> f64 {
     qs_final
 }
 
+// Original filterByExpr source code in edgeR: https://rdrr.io/bioc/edgeR/src/R/filterByExpr.R
 fn filter_by_expr(
+    min_count: f64,
+    min_total_count: f64,
     raw_data: &Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>,
     num_diseased: usize,
     num_control: usize,
@@ -960,9 +982,8 @@ fn filter_by_expr(
     Vec<String>,
 ) {
     // Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>
-    #[allow(non_upper_case_globals)]
-    const MIN_COUNT: f64 = 10.0; // Value of constant from R implementation
-    const MIN_TOTAL_COUNT: f64 = 15.0; // Value of constant from R implementation
+    //const min_count: f64 = 10.0; // Value of constant from R implementation
+    //const min_total_count: f64 = 15.0; // Value of constant from R implementation
     const LARGE_N: f64 = 10.0; // Value of constant from R implementation
     const MIN_PROP: f64 = 0.7; // Value of constant from R implementation
 
@@ -989,7 +1010,7 @@ fn filter_by_expr(
     //println!("lib_sizes:{:?}", lib_sizes);
     //println!("min_sample_size:{}", min_sample_size);
     let median_lib_size = Data::new(lib_sizes.clone()).median();
-    let cpm_cutoff = (MIN_COUNT / median_lib_size) * 1000000.0;
+    let cpm_cutoff = (min_count / median_lib_size) * 1000000.0;
     //println!("cpm_cutoff:{}", cpm_cutoff);
     let cpm_matrix = cpm(&raw_data);
     const TOL: f64 = 1e-14; // Value of constant from R implementation
@@ -1018,7 +1039,7 @@ fn filter_by_expr(
         //}
 
         let mut keep_total_bool = false;
-        if row_sums[(row, 0)] as f64 >= MIN_TOTAL_COUNT - TOL {
+        if row_sums[(row, 0)] as f64 >= min_total_count - TOL {
             keep_total_bool = true;
             //keep_total.push(keep_total_bool);
             //positive_total += 1;

package/src/genesetORA.rs

@@ -112,12 +112,12 @@ fn main() -> Result<()> {
                             + &genesetgroup
                             + "'"),
                     );
+                    let mut iter = 0;
                     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 mut iter = 0;
                             #[allow(non_snake_case)]
                             for GO_term in GO_iter {
                                 iter += 1;
@@ -178,14 +178,15 @@ fn main() -> Result<()> {
                                     }
                                 }
                             }
-                            println!("Number of pathway entries:{}", iter);
                         }
                         Err(_) => panic!("sqlite database file not found"),
                     }
-                    println!(
-                        "pathway_p_values:{}",
-                        adjust_p_values(pathway_p_values, num_items_output)
-                    );
+                    let output_string = "{\"num_pathways\":".to_string()
+                        + &iter.to_string()
+                        + &",\"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()
@@ -199,7 +200,10 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn adjust_p_values(mut original_p_values: Vec<pathway_p_value>, 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)
@@ -243,6 +247,10 @@ fn adjust_p_values(mut original_p_values: Vec<pathway_p_value>, num_items_output
             .unwrap_or(Ordering::Equal)
     });
 
+    if num_items_output > adjusted_p_values.len() {
+        num_items_output = adjusted_p_values.len()
+    }
+
     let mut output_string = "[".to_string();
     for i in 0..num_items_output {
         let j = adjusted_p_values.len() - i - 1;