@sjcrh/proteinpaint-rust 2.195.0 → 2.196.0

package/src/validateHDF5.rs

@@ -1,247 +0,0 @@
-// syntax:
-// echo '{"hdf5_file":"/path/to/my/local/file.h5"}' | ./target/release/validateHDF5
-
-use hdf5::types::{VarLenAscii, VarLenUnicode};
-use hdf5::{File, Result};
-use ndarray::Array1;
-use ndarray::Dim;
-use std::io;
-
-/// Detects the format of the HDF5 file
-pub fn detect_hdf5_format(hdf5_filename: &str) -> Result<&'static str> {
-    let file = File::open(hdf5_filename)?;
-
-    // Check for dense format (has counts, gene_names, and samples datasets)
-    let has_counts = file.dataset("counts").is_ok();
-    let has_gene_names = file.dataset("gene_names").is_ok();
-    let has_samples = file.dataset("samples").is_ok();
-
-    // Check for sparse matrix format (has data group and sample_names)
-    let has_data_group = file.group("data").is_ok();
-    let has_sample_names = file.dataset("sample_names").is_ok();
-
-    // Check for promoter DNA methylation format (has meta/samples/names)
-    let has_meta_sample_names = file.dataset("meta/samples/names").is_ok();
-
-    if has_counts && has_gene_names && has_samples {
-        // eprintln!("Dense format detected");
-        Ok("dense")
-    } else if has_data_group && has_sample_names {
-        // eprintln!("Sparse format detected");
-        Ok("sparse")
-    } else if has_meta_sample_names {
-        Ok("dna_meth_promoter")
-    } else {
-        // eprintln!("Unknown format detected");
-        Ok("unknown")
-    }
-}
-
-/// Validates and loads the HDF5 file
-pub fn validate_hdf5_file(hdf5_filename: String) -> Result<()> {
-    // Open the HDF5 file
-    let file = File::open(&hdf5_filename)?;
-
-    // Detect file format
-    let file_format = detect_hdf5_format(&hdf5_filename)?;
-
-    // Get basic information about the file depending on format
-    let output = match file_format {
-        "dense" => {
-            // For dense format, get dimensions from the counts dataset
-            let ds_counts = file.dataset("counts")?;
-            let data_shape = ds_counts.shape();
-
-            // Read sample names using VarLenAscii
-            let mut sample_names: Vec<String> = Vec::new();
-            if let Ok(ds_samples) = file.dataset("samples") {
-                if let Ok(samples) = ds_samples.read_1d::<VarLenAscii>() {
-                    for sample in samples.iter() {
-                        sample_names.push(sample.to_string());
-                    }
-                } else {
-                    eprintln!("Error reading samples as VarLenAscii");
-                }
-            }
-
-            // Read gene names using VarLenAscii
-            let mut gene_names: Vec<String> = Vec::new();
-            if let Ok(ds_genes) = file.dataset("gene_ids") {
-                if let Ok(genes) = ds_genes.read_1d::<VarLenAscii>() {
-                    for gene in genes.iter() {
-                        gene_names.push(gene.to_string());
-                    }
-                } else {
-                    eprintln!("Error reading gene_ids as VarLenAscii");
-                }
-            } else {
-                eprintln!("Could not find 'gene_ids' dataset");
-            }
-
-            // Create JSON with both sample names and gene names
-            serde_json::json!({
-                "status": "success",
-                "message": "HDF5 file loaded successfully",
-                "file_path": hdf5_filename,
-                "format": "dense",
-                "sampleNames": sample_names,
-                "matrix_dimensions": {
-                    "num_genes": data_shape[0],
-                    "num_samples": data_shape[1]
-                }
-            })
-        }
-        "sparse" => {
-            // For sparse format, get dimensions from the data/dim dataset
-            let ds_dim = file.dataset("data/dim")?;
-            let data_dim: Array1<usize> = ds_dim.read::<usize, Dim<[usize; 1]>>()?;
-            let num_samples = data_dim[0];
-            let num_genes = data_dim[1];
-
-            // Read sample names using VarLenAscii
-            let mut sample_names: Vec<String> = Vec::new();
-            if let Ok(ds_samples) = file.dataset("sample_names") {
-                if let Ok(samples) = ds_samples.read_1d::<VarLenAscii>() {
-                    for sample in samples.iter() {
-                        sample_names.push(sample.to_string());
-                    }
-                } else {
-                    eprintln!("Error reading sample_names as VarLenAscii");
-                }
-            }
-
-            // Read gene names using VarLenAscii
-            let mut gene_names: Vec<String> = Vec::new();
-            if let Ok(ds_genes) = file.dataset("gene_names") {
-                if let Ok(genes) = ds_genes.read_1d::<VarLenAscii>() {
-                    for gene in genes.iter() {
-                        gene_names.push(gene.to_string());
-                    }
-                } else {
-                    eprintln!("Error reading gene_names as VarLenAscii");
-                }
-            } else {
-                eprintln!("Could not find 'gene_names' dataset, trying alternatives");
-            }
-
-            // Create JSON with the same structure as dense format
-            serde_json::json!({
-                "status": "success",
-                "message": "HDF5 file loaded successfully",
-                "file_path": hdf5_filename,
-                "format": "sparse",
-                "sampleNames": sample_names,
-                "matrix_dimensions": {
-                    "num_genes": num_genes,
-                    "num_samples": num_samples
-                }
-            })
-        }
-        "dna_meth_promoter" => {
-            // For promoter DNA methylation format - only read sample names
-            let mut sample_names: Vec<String> = Vec::new();
-            if let Ok(ds_samples) = file.dataset("meta/samples/names") {
-                if let Ok(samples) = ds_samples.read_1d::<VarLenUnicode>() {
-                    for sample in samples.iter() {
-                        sample_names.push(sample.to_string());
-                    }
-                } else {
-                    eprintln!("Error reading meta/samples/names as VarLenUnicode");
-                }
-            }
-
-            serde_json::json!({
-                "status": "success",
-                "message": "HDF5 promoter DNA methylation file loaded successfully",
-                "file_path": hdf5_filename,
-                "format": "dna_meth_promoter",
-                "sampleNames": sample_names
-            })
-        }
-        _ => {
-            // For unknown format
-            serde_json::json!({
-                "status": "failure",
-                "message": "Unknown file format cannot be loaded successfully",
-                "file_path": hdf5_filename,
-                "format": "unknown",
-                "sampleNames": [],
-                "geneNames": []
-            })
-        }
-    };
-
-    // Print the output
-    println!("{}", output);
-
-    Ok(())
-}
-
-/// Main function to handle the validation process
-fn main() -> Result<()> {
-    let mut input = String::new();
-    match io::stdin().read_line(&mut input) {
-        Ok(_bytes_read) => {
-            let input_json = json::parse(&input);
-            match input_json {
-                Ok(json_string) => {
-                    // Extract HDF5 filename
-                    let hdf5_filename = match json_string["hdf5_file"].as_str() {
-                        Some(x) => x.to_string(),
-                        None => {
-                            eprintln!("HDF5 filename not provided");
-                            println!(
-                                "{}",
-                                serde_json::json!({
-                                    "status": "error",
-                                    "message": "HDF5 filename not provided"
-                                })
-                            );
-                            return Ok(());
-                        }
-                    };
-
-                    // Log the start of validation
-                    // let start_time = Instant::now();
-                    // eprintln!("Starting validation of file: {}", hdf5_filename);
-
-                    // Run the validation
-                    if let Err(err) = validate_hdf5_file(hdf5_filename.clone()) {
-                        eprintln!("Error validating HDF5 file: {:?}", err);
-                        println!(
-                            "{}",
-                            serde_json::json!({
-                                "status": "error",
-                                "message": format!("Error validating HDF5 file: {}", err)
-                            })
-                        );
-                    }
-
-                    // Log completion time
-                    // eprintln!("Validation completed in: {:?}", start_time.elapsed());
-                }
-                Err(error) => {
-                    eprintln!("Incorrect JSON: {}", error);
-                    println!(
-                        "{}",
-                        serde_json::json!({
-                            "status": "error",
-                            "message": format!("Invalid JSON input: {}", error)
-                        })
-                    );
-                }
-            }
-        }
-        Err(error) => {
-            eprintln!("Piping error: {}", error);
-            println!(
-                "{}",
-                serde_json::json!({
-                    "status": "error",
-                    "message": format!("Error reading input: {}", error)
-                })
-            );
-        }
-    }
-    Ok(())
-}