@sjcrh/proteinpaint-rust 2.195.0 → 2.196.0

package/src/readH5.rs

@@ -1,781 +0,0 @@
-// readH5.rs - validate/read HDF5 file
-//
-// READ:
-// Extracts matrix from HDF5 files.
-// Matrix dataset is hardcoded as "matrix". row_dataset(samples) and col_dataset(genesets)
-// row_dataset and col_dataset are stored as VarLenUnicode.
-// Supports f32, f64, i32 and i64 matrix datatypes.
-//
-// Features:
-// - Hardcoded "matrix" dataset
-// - Supports f32, f64, i32 and i64 matrix datatypes
-// - Parallel processing with dynamic thread count
-// - JSON output with timing metrics
-
-// Usage
-// echo '{"query":["HALLMARK_ADIPOGENESIS", "HALLMARK_ANGIOGENESIS"],"hdf5_file":"matrix.h5"}' | ./target/release/readH5
-//
-//
-// VLIDATE:
-// output: JSON with {"samples":[]}
-// Usage
-// echo '{"validate":true,"hdf5_file":"matrix.h5"}' | ./target/release/readH5
-
-use hdf5::types::VarLenUnicode;
-use hdf5::{File, Result, Selection};
-use json::JsonValue;
-use ndarray::Dim;
-use rayon::prelude::*;
-use serde_json::{Map, Value, json};
-use std::io;
-use std::sync::Arc;
-use std::time::Instant;
-
-/// Creates an error JSON response
-fn error_response(message: impl Into<String>) -> Value {
-    json!({
-        "status": "error",
-        "message": message.into()
-    })
-}
-
-/// **Bulk mode**: Reads the entire matrix once, then extracts requested rows (genes).
-/// Much faster than many small slice reads when querying many genes (>50–100).
-pub fn bulk_query_hdf5(filename: &str, query_items: &[String]) -> Result<Map<String, Value>> {
-    let start = Instant::now();
-
-    let file = match File::open(filename) {
-        Ok(f) => f,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!("Failed to open HDF5 file: {}", err)));
-        }
-    };
-
-    // Read all items (genes)
-    let items_dataset = match file.dataset("item") {
-        Ok(ds) => ds,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!("Failed to open items dataset: {}", err)));
-        }
-    };
-
-    // Read items as VarLenAscii
-    let items_varlen = match items_dataset.read_1d::<VarLenUnicode>() {
-        Ok(g) => g,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!("Failed to read items(genes): {}", err)));
-        }
-    };
-
-    let item_names: Vec<String> = items_varlen.iter().map(|g| g.to_string()).collect();
-    //let num_items = item_names.len();
-
-    // Read all samples names ("samples")
-    let samples_dataset = match file.dataset("samples") {
-        Ok(ds) => ds,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!(
-                "Failed to open samples dataset: {}",
-                err
-            )));
-        }
-    };
-
-    let samples_varlen = match samples_dataset.read_1d::<VarLenUnicode>() {
-        Ok(s) => s,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!("Failed to read sample names: {}", err)));
-        }
-    };
-
-    let all_samples: Vec<String> = samples_varlen.iter().map(|s| s.to_string()).collect();
-
-    // Find row indices
-    let mut row_indices: Vec<usize> = Vec::with_capacity(query_items.len());
-    let mut found_items: Vec<String> = Vec::with_capacity(query_items.len());
-
-    for item in query_items {
-        if let Some(idx) = item_names.iter().position(|i| i == item) {
-            row_indices.push(idx);
-            found_items.push(item.clone());
-        } else {
-            return Err(hdf5::Error::Internal(format!("Item '{}' not found", item)));
-        }
-    }
-
-    // Read the ENTIRE matrix once (the key for speed in bulk)
-    let matrix_ds = match file.dataset("matrix") {
-        Ok(ds) => ds,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!(
-                "Failed to open 'matrix' dataset: {}",
-                err
-            )));
-        }
-    };
-
-    let shape = matrix_ds.shape();
-    if shape.len() != 2 {
-        return Err(hdf5::Error::Internal("Matrix must be 2D".into()));
-    };
-
-    let all_data = match matrix_ds.read::<f64, Dim<[usize; 2]>>() {
-        Ok(data) => data,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!(
-                "Failed to read expression data: {}",
-                err
-            )));
-        }
-    };
-
-    // build the same output structure as query_dataset
-    let mut query_output = Map::new();
-    let mut timings = Map::new();
-
-    for (i, &row_idx) in row_indices.iter().enumerate() {
-        let item = &found_items[i];
-        let query_start = Instant::now();
-
-        let mut sample_map = Map::new();
-        for (s_idx, sample) in all_samples.iter().enumerate() {
-            let val = all_data[[row_idx, s_idx]];
-            sample_map.insert(
-                sample.replace("\\", ""),
-                if val.is_finite() { json!(val) } else { Value::Null },
-            );
-        }
-        query_output.insert(
-            item.replace("\\", ""),
-            json!({
-                "dataId": item,
-                "samples": sample_map
-            }),
-        );
-        let elapsed = query_start.elapsed().as_millis() as u64;
-        query_output.insert(format!("{}_ms", item), Value::from(elapsed));
-    }
-
-    timings.insert(
-        "read_full_matrix_ms".to_string(),
-        Value::from(start.elapsed().as_millis() as u64),
-    );
-    timings.insert("query_count".to_string(), Value::from(query_items.len()));
-
-    Ok(query_output)
-}
-
-/// h5 file validation
-// Detects if the HDF5 file contains a valid matrix dataset
-pub fn detect_hdf5_format(
-    hdf5_filename: &str,
-    matrix_name: &str,
-    row_dataset: &str,
-    col_dataset: &str,
-) -> Result<&'static str> {
-    let file = File::open(hdf5_filename)?;
-
-    // Check for matrix dataset (must be 2D)
-    let matrix_ok = file
-        .dataset(matrix_name)
-        .map(|dataset| dataset.shape().len() == 2)
-        .unwrap_or(false);
-
-    // Check for row dataset (must exist and contain VarLenAscii)
-    let row_ok = file
-        .dataset(row_dataset)
-        .and_then(|ds| ds.read_1d::<hdf5::types::VarLenUnicode>())
-        .is_ok();
-
-    // Check for column dataset (must exist and contain VarLenAscii)
-    let col_ok = file
-        .dataset(col_dataset)
-        .and_then(|ds| ds.read_1d::<hdf5::types::VarLenUnicode>())
-        .is_ok();
-
-    if matrix_ok && row_ok && col_ok {
-        Ok("matrix")
-    } else {
-        Ok("unknown")
-    }
-}
-
-pub fn validate_hdf5_file(hdf5_filename: String, include_items: bool) -> Result<()> {
-    let file = File::open(&hdf5_filename)?;
-    let matrix_name = "matrix";
-    let row_dataset = "samples";
-    let col_dataset = "item";
-    let file_format = detect_hdf5_format(&hdf5_filename, matrix_name, row_dataset, col_dataset)?;
-
-    let output = match file_format {
-        "matrix" => {
-            let dataset = file.dataset(matrix_name)?;
-            let matrix_shape = dataset.shape();
-            let datatype = dataset.dtype()?;
-
-            // Read row_dataset as VarLenUnicode
-            let row_dataset_data = file.dataset(row_dataset)?;
-            let row_data: Vec<String> = row_dataset_data
-                .read_1d::<VarLenUnicode>()?
-                .iter()
-                .map(|s| s.to_string())
-                .collect();
-
-            // Validate matrix data
-            let matrix_valid = if matrix_shape.len() == 2 && matrix_shape[0] > 0 && matrix_shape[1] > 0 {
-                // Create a selection for a 1x1 slice at (0,0)
-                let selection = hdf5::Selection::from((0..1, 0..1));
-
-                if datatype.is::<f64>() {
-                    dataset.read_slice_2d::<f64, _>(selection).is_ok()
-                } else if datatype.is::<f32>() {
-                    dataset.read_slice_2d::<f32, _>(selection).is_ok()
-                } else if datatype.is::<i32>() {
-                    dataset.read_slice_2d::<i32, _>(selection).is_ok()
-                } else if datatype.is::<i64>() {
-                    dataset.read_slice_2d::<i64, _>(selection).is_ok()
-                } else {
-                    false
-                }
-            } else {
-                false
-            };
-
-            let mut result = json!({
-                "status": if matrix_valid { "success" } else { "failure" },
-                "message": if matrix_valid {
-                    "HDF5 matrix file loaded successfully"
-                } else {
-                    "Invalid matrix structure"
-                },
-                "file_path": hdf5_filename,
-                "format": "matrix",
-                "matrix_dimensions": {
-                    "num_rows": matrix_shape.get(0).unwrap_or(&0),
-                    "num_columns": matrix_shape.get(1).unwrap_or(&0)
-                },
-                row_dataset.to_string(): row_data
-            });
-
-            // Optionally include item names (e.g. isoform IDs) in the response
-            if include_items {
-                let col_dataset_data = file.dataset(col_dataset)?;
-                let col_data: Vec<String> = col_dataset_data
-                    .read_1d::<VarLenUnicode>()?
-                    .iter()
-                    .map(|s| s.to_string())
-                    .collect();
-                result["items"] = json!(col_data);
-            }
-
-            result
-        }
-        _ => {
-            json!({
-                "status": "failure",
-                "message": format!(
-                    "Missing or invalid required datasets: matrix='{}', row_dataset='{}', col_dataset='{}'",
-                    matrix_name, row_dataset, col_dataset
-                ),
-                "file_path": hdf5_filename,
-                "format": "unknown",
-                "matrix_dimensions": {
-                    "num_rows": 0,
-                    "num_columns": 0
-                }
-            })
-        }
-    };
-    println!("{}", output);
-    Ok(())
-}
-
-/// read h5 file
-
-// Trait for converting types to f64, allowing lossy conversions
-trait ToF64 {
-    fn to_f64(&self) -> f64;
-}
-
-impl ToF64 for f32 {
-    fn to_f64(&self) -> f64 {
-        *self as f64
-    }
-}
-
-impl ToF64 for f64 {
-    fn to_f64(&self) -> f64 {
-        *self
-    }
-}
-
-impl ToF64 for i32 {
-    fn to_f64(&self) -> f64 {
-        *self as f64
-    }
-}
-
-impl ToF64 for i64 {
-    fn to_f64(&self) -> f64 {
-        if self.abs() > (1 << 53) {
-            eprintln!("Warning: i64 value {} may lose precision when converted to f64", self);
-        }
-        *self as f64
-    }
-}
-
-// Process matrix data for a given type
-fn process_data<T: ToF64 + Copy>(data: &[T], row_data: &[String]) -> Map<String, Value> {
-    let mut row_data_map = Map::new();
-    for (i, row) in row_data.iter().enumerate() {
-        if i < data.len() {
-            let value = data[i].to_f64();
-            row_data_map.insert(
-                row.replace("\\", ""),
-                if value.is_finite() {
-                    Value::from(value)
-                } else {
-                    Value::Null
-                },
-            );
-        }
-    }
-    row_data_map
-}
-
-// Data query
-// Supports f32, f64, i32 and i64 datatypes for the matrix dataset.
-// Uses hardcoded "matrix", "samples" and "item" dataset.
-// "samples" and "item" datasets are read as VarLenUnicode.
-//
-// # Arguments
-// * `hdf5_filenam` - Path to the HDF5 file
-// * `qry` - Query (non-empty array)
-//
-// # Returns
-// Prints a JSON object with matrix data for query data to stdout
-fn query_dataset(hdf5_filename: String, qry: Vec<String>) -> Result<()> {
-    let overall_start_time = Instant::now();
-    let mut timings = Map::new();
-    timings.insert("query_count".to_string(), Value::from(qry.len()));
-
-    let file = match File::open(&hdf5_filename) {
-        Ok(f) => f,
-        Err(err) => {
-            println!("{}", error_response(format!("Failed to open HDF5 file: {}", err)));
-            return Ok(());
-        }
-    };
-
-    let col_dataset_name = String::from("item");
-    let col_dataset = match file.dataset(&col_dataset_name) {
-        Ok(ds) => ds,
-        Err(err) => {
-            println!(
-                "{}",
-                error_response(format!("Failed to open {} dataset: {}", col_dataset_name, err))
-            );
-            return Ok(());
-        }
-    };
-
-    let col_dataset_varlen = match col_dataset.read_1d::<VarLenUnicode>() {
-        Ok(g) => g,
-        Err(err) => {
-            println!(
-                "{}",
-                error_response(format!("Failed to read {}: {}", col_dataset_name, err))
-            );
-            return Ok(());
-        }
-    };
-    let col_data: Vec<String> = col_dataset_varlen.iter().map(|g| g.to_string()).collect();
-
-    let hashmap_start_time = Instant::now();
-    let col_data_to_index: std::collections::HashMap<String, usize> =
-        col_data.iter().enumerate().map(|(i, g)| (g.clone(), i)).collect();
-    timings.insert(
-        "build_hashmap_ms".to_string(),
-        Value::from(hashmap_start_time.elapsed().as_millis() as u64),
-    );
-
-    let row_dataset_name = String::from("samples");
-    let row_dataset = match file.dataset(&row_dataset_name) {
-        Ok(ds) => ds,
-        Err(err) => {
-            println!(
-                "{}",
-                error_response(format!("Failed to open {} dataset: {}", row_dataset_name, err))
-            );
-            return Ok(());
-        }
-    };
-    let row_dataset_varlen = match row_dataset.read_1d::<VarLenUnicode>() {
-        Ok(s) => s,
-        Err(err) => {
-            println!(
-                "{}",
-                error_response(format!("Failed to read {}: {}", row_dataset_name, err))
-            );
-            return Ok(());
-        }
-    };
-    let row_data: Vec<String> = row_dataset_varlen.iter().map(|s| s.to_string()).collect();
-
-    let matrix_dataset = match file.dataset("matrix") {
-        Ok(ds) => ds,
-        Err(err) => {
-            println!("{}", error_response(format!("Failed to open matrix dataset: {}", err)));
-            return Ok(());
-        }
-    };
-
-    let datatype = match matrix_dataset.dtype() {
-        Ok(dt) => dt,
-        Err(err) => {
-            println!("{}", error_response(format!("Failed to read matrix datatype: {}", err)));
-            return Ok(());
-        }
-    };
-
-    let col_data_map = Arc::new(std::sync::Mutex::new(Map::new()));
-    let thread_count = std::cmp::min(4, qry.len());
-    timings.insert("thread_count".to_string(), Value::from(thread_count));
-
-    let results: Vec<(String, Value)> = match rayon::ThreadPoolBuilder::new()
-        .num_threads(thread_count)
-        .build()
-    {
-        Ok(pool) => pool.install(|| {
-            qry
-                .par_iter()
-                .map(|query| {
-                    let query_start_time = Instant::now();
-                    let result = match col_data_to_index.get(query) {
-                        Some(&index) => {
-                            if index >= matrix_dataset.shape()[0] {
-                                let mut error_map = Map::new();
-                                error_map.insert(
-                                    "error".to_string(),
-                                    Value::String("Query index out of bounds".to_string()),
-                                );
-                                (query.clone(), Value::Object(error_map))
-                            } else {
-                                let selection = Selection::from((index..index+1, ..));
-                                if datatype.is::<f64>() {
-                                    match matrix_dataset.read_slice_2d::<f64,_>(selection) {
-                                        Ok(data) => (
-                                            query.clone(),
-                                            json!({
-                                                "dataId": query,
-                                                row_dataset_name.clone(): process_data(data.as_slice().unwrap(), &row_data)
-                                            }),
-                                        ),
-                                        Err(err) => {
-                                            let mut error_map = Map::new();
-                                            error_map.insert(
-                                                "error".to_string(),
-                                                Value::String(format!("Failed to read f64 matrix values: {}", err)),
-                                            );
-                                            (query.clone(), Value::Object(error_map))
-                                        }
-                                    }
-                                } else if datatype.is::<f32>() {
-                                    match matrix_dataset.read_slice_2d::<f32,_>(selection) {
-                                        Ok(data) => (
-                                            query.clone(),
-                                            json!({
-                                                "dataId": query,
-                                                row_dataset_name.clone(): process_data(data.as_slice().unwrap(), &row_data)
-                                            }),
-                                        ),
-                                        Err(err) => {
-                                            let mut error_map = Map::new();
-                                            error_map.insert(
-                                                "error".to_string(),
-                                                Value::String(format!("Failed to read f32 matrix values: {}", err)),
-                                            );
-                                            (query.clone(), Value::Object(error_map))
-                                        }
-                                    }
-                                } else if datatype.is::<i32>() {
-                                    match matrix_dataset.read_slice_2d::<i32,_>(selection) {
-                                         Ok(data) => (
-                                            query.clone(),
-                                            json!({
-                                                "dataId": query,
-                                                row_dataset_name.clone(): process_data(data.as_slice().unwrap(), &row_data)
-                                            }),
-                                        ),
-                                        Err(err) => {
-                                            let mut error_map = Map::new();
-                                            error_map.insert(
-                                                "error".to_string(),
-                                                Value::String(format!("Failed to read i32 matrix values: {}", err)),
-                                            );
-                                            (query.clone(), Value::Object(error_map))
-                                        }
-                                    }
-                                } else if datatype.is::<i64>() {
-                                    match matrix_dataset.read_slice_2d::<i64,_>(selection) {
-                                        Ok(data) => (
-                                            query.clone(),
-                                            json!({
-                                                "dataId": query,
-                                                row_dataset_name.clone(): process_data(data.as_slice().unwrap(), &row_data)
-                                            }),
-                                        ),
-                                        Err(err) => {
-                                            let mut error_map = Map::new();
-                                            error_map.insert(
-                                                "error".to_string(),
-                                                Value::String(format!("Failed to read i64 matrix values: {}", err)),
-                                            );
-                                            (query.clone(), Value::Object(error_map))
-                                        }
-                                    }
-                                } else {
-                                    let mut error_map = Map::new();
-                                    error_map.insert(
-                                        "error".to_string(),
-                                        Value::String("Unsupported matrix datatype (expected f64, f32, i64 or i32)".to_string()),
-                                    );
-                                    (query.clone(), Value::Object(error_map))
-                                }
-                            }
-                        }
-                        None => {
-                            let mut error_map = Map::new();
-                            error_map.insert(
-                                "error".to_string(),
-                                Value::String(format!("Query '{}' not found in {} dataset", query, col_dataset_name)),
-                            );
-                            (query.clone(),Value::Object(error_map))
-                        }
-                    };
-                    let elapsed_time = query_start_time.elapsed().as_millis() as u64;
-                    let mut query_timings = col_data_map.lock().unwrap();
-                    query_timings.insert(
-                        format!("{}_ms", query),
-                        Value::from(elapsed_time),
-                    );
-                    result
-                })
-                .collect()
-        }),
-        Err(err) => {
-            timings.insert(
-                "thread_pool_error".to_string(),
-                Value::String(format!("Failed to create thread pool: {}", err)),
-            );
-            qry
-                .iter()
-                .map(|query| {
-                    let query_start_time = Instant::now();
-                    let result = match col_data_to_index.get(query) {
-                        Some(&index) => {
-                            if index >= matrix_dataset.shape()[0] {
-                                let mut error_map = Map::new();
-                                error_map.insert(
-                                    "error".to_string(),
-                                    Value::String("Query index out of bounds".to_string()),
-                                );
-                                (query.clone(), Value::Object(error_map))
-                            } else {
-                                let selection = Selection::from((index..index+1, ..));
-                                if datatype.is::<f64>() {
-                                    match matrix_dataset.read_slice_1d::<f64,_>(selection) {
-                                        Ok(data) => (
-                                            query.clone(),
-                                            json!({
-                                                "dataId": query,
-                                                row_dataset_name.clone(): process_data(data.as_slice().unwrap(), &row_data)
-                                            }),
-                                        ),
-                                        Err(err) => {
-                                            let mut error_map = Map::new();
-                                            error_map.insert(
-                                                "error".to_string(),
-                                                Value::String(format!("Failed to read f64 matrix values: {}", err)),
-                                            );
-                                            (query.clone(), Value::Object(error_map))
-                                        }
-                                    }
-                                } else if datatype.is::<f32>() {
-                                    match matrix_dataset.read_slice_1d::<f32,_>(selection) {
-                                        Ok(data) => (
-                                            query.clone(),
-                                            json!({
-                                                "dataId": query,
-                                                row_dataset_name.clone(): process_data(data.as_slice().unwrap(), &row_data)
-                                            }),
-                                        ),
-                                        Err(err) => {
-                                            let mut error_map = Map::new();
-                                            error_map.insert(
-                                                "error".to_string(),
-                                                Value::String(format!("Failed to read f32 matrix values: {}", err)),
-                                            );
-                                            (query.clone(), Value::Object(error_map))
-                                        }
-                                    }
-                                } else if datatype.is::<i32>() {
-                                    match matrix_dataset.read_slice_1d::<i32,_>(selection) {
-                                         Ok(data) => (
-                                            query.clone(),
-                                            json!({
-                                                "dataId": query,
-                                                row_dataset_name.clone(): process_data(data.as_slice().unwrap(), &row_data)
-                                            }),
-                                        ),
-                                        Err(err) => {
-                                            let mut error_map = Map::new();
-                                            error_map.insert(
-                                                "error".to_string(),
-                                                Value::String(format!("Failed to read i32 matrix values: {}", err)),
-                                            );
-                                            (query.clone(), Value::Object(error_map))
-                                        }
-                                    }
-                                } else if datatype.is::<i64>() {
-                                    match matrix_dataset.read_slice_1d::<i64,_>(selection) {
-                                        Ok(data) => (
-                                            query.clone(),
-                                            json!({
-                                                "dataId": query,
-                                                row_dataset_name.clone(): process_data(data.as_slice().unwrap(), &row_data)
-                                            }),
-                                        ),
-                                        Err(err) => {
-                                            let mut error_map = Map::new();
-                                            error_map.insert(
-                                                "error".to_string(),
-                                                Value::String(format!("Failed to read i64 matrix values: {}", err)),
-                                            );
-                                            (query.clone(), Value::Object(error_map))
-                                        }
-                                    }
-                                } else {
-                                    let mut error_map = Map::new();
-                                    error_map.insert(
-                                        "error".to_string(),
-                                        Value::String("Unsupported matrix datatype (expected f64, f32, i64 or i32)".to_string()),
-                                    );
-                                    (query.clone(), Value::Object(error_map))
-                                }
-                            }
-                        }
-                        None => {
-                            let mut error_map = Map::new();
-                            error_map.insert(
-                                "error".to_string(),
-                                Value::String(format!("Query '{}' not found in {} dataset", query, col_dataset_name)),
-                            );
-                            (query.clone(),Value::Object(error_map))
-                        }
-                    };
-                    let elapsed_time = query_start_time.elapsed().as_millis() as u64;
-                    let mut query_timings = col_data_map.lock().unwrap();
-                    query_timings.insert(
-                        format!("{}_ms", query),
-                        Value::from(elapsed_time),
-                    );
-                    result
-                })
-                .collect()
-        }
-    };
-
-    let mut col_data_map = col_data_map.lock().unwrap();
-    for (query, query_data) in results {
-        col_data_map.insert(query, query_data);
-    }
-
-    let output_json = json!({
-        "query_output": *col_data_map,
-        "timings": timings,
-        "total_time_ms": overall_start_time.elapsed().as_millis() as u64
-    });
-    println!("{}", output_json);
-    Ok(())
-}
-
-/// Main function to handle both validation and read of h5 file
-fn main() -> Result<()> {
-    let mut input = String::new();
-    match io::stdin().read_line(&mut input) {
-        Ok(_bytes_read) => {
-            let input_json = match json::parse(&input) {
-                Ok(json) => json,
-                Err(_err) => {
-                    panic!("Invalid JSON input");
-                }
-            };
-
-            // Extract HDF5 filename
-            let hdf5_filename = match input_json["hdf5_file"].as_str() {
-                Some(x) => x.to_string(),
-                None => {
-                    println!("{}", error_response("HDF5 filename not provided"));
-                    return Ok(());
-                }
-            };
-
-            let read_mode = input_json["read_mode"].as_str().unwrap_or("default").to_lowercase();
-
-            // h5 file validation
-            if input_json.has_key("validate") {
-                let v: bool = match input_json["validate"].as_bool() {
-                    Some(x) => x,
-                    None => false,
-                };
-                if v {
-                    let include_items = input_json["include_items"].as_bool().unwrap_or(false);
-                    let _ = validate_hdf5_file(hdf5_filename, include_items);
-                } else {
-                    println!("{}", error_response("The value of validate is invalid"));
-                }
-                return Ok(());
-            };
-
-            // Get query items
-            let qry: Vec<String> = match &input_json["query"] {
-                JsonValue::Array(arr) => arr.iter().filter_map(|v| v.as_str().map(|s| s.to_string())).collect(),
-                _ => vec![],
-            };
-
-            if qry.is_empty() {
-                println!("{}", error_response(format!("query is empty")));
-                return Ok(());
-            }
-
-            let overall_start = Instant::now();
-
-            if read_mode == "bulk" {
-                // ====================== BULK MODE ======================
-                match bulk_query_hdf5(&hdf5_filename, &qry) {
-                    Ok(query_output) => {
-                        let output_json = json!({
-                            "query_output": query_output,
-                            "timings": {
-                                "query_count": qry.len(),
-                                "read_mode": "bulk"
-                            },
-                            "total_time_ms": overall_start.elapsed().as_millis() as u64
-                        });
-                        println!("{}", output_json);
-                    }
-                    Err(e) => {
-                        println!("{}", error_response(format!("Bulk query failed: {}", e)));
-                    }
-                }
-            } else {
-                let _ = query_dataset(hdf5_filename, qry);
-            }
-        }
-        Err(error) => {
-            println!("{}", error_response(format!("Error reading input: {}", error)));
-        }
-    }
-    Ok(())
-}