@sjcrh/proteinpaint-rust 2.167.0 → 2.169.0

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.167.0",
+	"version": "2.169.0",
 	"name": "@sjcrh/proteinpaint-rust",
 	"type": "module",
 	"description": "Rust-based utilities for proteinpaint",

package/src/aichatbot.rs

@@ -30,21 +30,51 @@ pub struct AiJsonFormat {
 #[derive(PartialEq, Debug, Clone, schemars::JsonSchema, serde::Serialize, serde::Deserialize)]
 enum Charts {
     // More chart types will be added here later
-    Summary(TrainTestData),
-    DE(TrainTestData),
+    Summary(TrainTestDataSummary),
+    DE(TrainTestDataDE),
 }
 
 #[derive(PartialEq, Debug, Clone, schemars::JsonSchema, serde::Serialize, serde::Deserialize)]
-struct TrainTestData {
+struct TrainTestDataSummary {
     SystemPrompt: String,
-    TrainingData: Vec<QuestionAnswer>,
-    TestData: Vec<QuestionAnswer>,
+    TrainingData: Vec<QuestionAnswerSummary>,
+    TestData: Vec<QuestionAnswerSummary>,
 }
 
 #[derive(PartialEq, Debug, Clone, schemars::JsonSchema, serde::Serialize, serde::Deserialize)]
-struct QuestionAnswer {
+struct QuestionAnswerSummary {
     question: String,
-    answer: String,
+    answer: SummaryType,
+}
+
+#[derive(PartialEq, Debug, Clone, schemars::JsonSchema, serde::Serialize, serde::Deserialize)]
+struct TrainTestDataDE {
+    SystemPrompt: String,
+    TrainingData: Vec<QuestionAnswerDE>,
+    TestData: Vec<QuestionAnswerDE>,
+}
+
+#[derive(PartialEq, Debug, Clone, schemars::JsonSchema, serde::Serialize, serde::Deserialize)]
+struct QuestionAnswerDE {
+    question: String,
+    answer: DEType,
+}
+
+#[derive(PartialEq, Debug, Clone, schemars::JsonSchema, serde::Serialize, serde::Deserialize)]
+struct DEType {
+    action: String,
+    DE_output: DETerms,
+}
+
+#[derive(PartialEq, Debug, Clone, schemars::JsonSchema, serde::Serialize, serde::Deserialize)]
+struct DETerms {
+    group1: GroupType,
+    group2: GroupType,
+}
+
+#[derive(PartialEq, Debug, Clone, schemars::JsonSchema, serde::Serialize, serde::Deserialize)]
+struct GroupType {
+    name: String,
 }
 
 #[allow(non_camel_case_types)]
@@ -77,6 +107,27 @@ async fn main() -> Result<()> {
                         None => panic!("user_input field is missing in input json"),
                     }
 
+                    let dataset_db_json: &JsonValue = &json_string["dataset_db"];
+                    let dataset_db_str: &str;
+                    match dataset_db_json.as_str() {
+                        Some(inp) => dataset_db_str = inp,
+                        None => panic!("dataset_db field is missing in input json"),
+                    }
+
+                    let genedb_json: &JsonValue = &json_string["genedb"];
+                    let genedb_str: &str;
+                    match genedb_json.as_str() {
+                        Some(inp) => genedb_str = inp,
+                        None => panic!("genedb field is missing in input json"),
+                    }
+
+                    let aiRoute_json: &JsonValue = &json_string["aiRoute"];
+                    let aiRoute_str: &str;
+                    match aiRoute_json.as_str() {
+                        Some(inp) => aiRoute_str = inp,
+                        None => panic!("aiRoute field is missing in input json"),
+                    }
+
                     if user_input.len() == 0 {
                         panic!("The user input is empty");
                     }
@@ -124,8 +175,9 @@ async fn main() -> Result<()> {
                     let ai_json: AiJsonFormat =
                         serde_json::from_str(&ai_data).expect("AI JSON file does not have the correct format");
 
-                    let genedb = String::from(tpmasterdir) + &"/" + &ai_json.genedb;
-                    let dataset_db = String::from(tpmasterdir) + &"/" + &ai_json.db;
+                    let genedb = String::from(tpmasterdir) + &"/" + &genedb_str;
+                    let dataset_db = String::from(tpmasterdir) + &"/" + &dataset_db_str;
+                    let airoute = String::from(binpath) + &"/../../" + &aiRoute_str;
 
                     let apilink_json: &JsonValue = &json_string["apilink"];
                     let apilink: &str;
@@ -185,6 +237,7 @@ async fn main() -> Result<()> {
                             &dataset_db,
                             &genedb,
                             &ai_json,
+                            &airoute,
                             testing,
                         )
                         .await;
@@ -208,6 +261,7 @@ async fn main() -> Result<()> {
                             &dataset_db,
                             &genedb,
                             &ai_json,
+                            &airoute,
                             testing,
                         )
                         .await;
@@ -241,6 +295,7 @@ pub async fn run_pipeline(
     dataset_db: &str,
     genedb: &str,
     ai_json: &AiJsonFormat,
+    ai_route: &str,
     testing: bool,
 ) -> Option<String> {
     let mut classification: String = classify_query_by_dataset_type(
@@ -251,6 +306,7 @@ pub async fn run_pipeline(
         temperature,
         max_new_tokens,
         top_p,
+        ai_route,
     )
     .await;
     classification = classification.replace("\"", "");
@@ -376,101 +432,33 @@ pub async fn run_pipeline(
 async fn classify_query_by_dataset_type(
     user_input: &str,
     comp_model: impl rig::completion::CompletionModel + 'static,
-    embedding_model: impl rig::embeddings::EmbeddingModel + 'static,
+    _embedding_model: impl rig::embeddings::EmbeddingModel + 'static,
     llm_backend_type: &llm_backend,
     temperature: f64,
     max_new_tokens: usize,
     top_p: f32,
+    ai_route: &str,
 ) -> String {
-    // Create a string to hold the file contents
-    let contents = String::from("SNV/SNP or point mutations nucleotide mutations are very common forms of mutations which can often give rise to genetic diseases such as cancer, Alzheimer's disease etc. They can be duw to substitution of nucleotide, or insertion or deletion of a nucleotide. Indels are multi-nucleotide insertion/deletion/substitutions. Complex indels are indels where insertion and deletion have happened in the same genomic locus. Every genomic sample from each patient has its own set of mutations therefore requiring personalized treatment. 
-
-If a ProteinPaint dataset contains SNV/Indel/SV data then return JSON with single key, 'snv_indel'.
-
----
-
-Copy number variation (CNV) is a phenomenon in which sections of the genome are repeated and the number of repeats in the genome varies between individuals.[1] Copy number variation is a special type of structural variation: specifically, it is a type of duplication or deletion event that affects a considerable number of base pairs.
-
-If a ProteinPaint dataset contains copy number variation data then return JSON with single key, 'cnv'.
-
----
-
-Structural variants/fusions (SV) are genomic mutations when eith a DNA region is translocated or copied to an entirely different genomic locus. In case of transcriptomic data, when RNA is fused from two different genes its called a gene fusion.
-
-If a ProteinPaint dataset contains structural variation or gene fusion data then return JSON with single key, 'sv_fusion'.
----
-
-Hierarchical clustering of gene expression is an unsupervised learning technique where several number of relevant genes and the samples are clustered so as to determine (previously unknown) cohorts of samples (or patients) or structure in data. It is very commonly used to determine subtypes of a particular disease based on RNA sequencing data. 
-
-If a ProteinPaint dataset contains hierarchical data then return JSON with single key, 'hierarchical'.
-
----
-
-Differential Gene Expression (DGE or DE) is a technique where the most upregulated (or highest) and downregulated (or lowest) genes between two cohorts of samples (or patients) are determined from a pool of THOUSANDS of genes. Differential gene expression CANNOT be computed for a SINGLE gene. A volcano plot is shown with fold-change in the x-axis and adjusted p-value on the y-axis. So, the upregulated and downregulared genes are on opposite sides of the graph and the most significant genes (based on adjusted p-value) is on the top of the graph. Following differential gene expression generally GeneSet Enrichment Analysis (GSEA) is carried out where based on the genes and their corresponding fold changes the upregulation/downregulation of genesets (or pathways) is determined.
-
-Sample Query1: \"Which gene has the highest expression between the two genders\"
-Sample Answer1: { \"answer\": \"dge\" }
-
-Sample Query2: \"Which gene has the lowest expression between the two races\"
-Sample Answer2: { \"answer\": \"dge\" }
-
-Sample Query1: \"Which genes are the most upregulated genes between group A and group B\"
-Sample Answer1: { \"answer\": \"dge\" }
-
-Sample Query3: \"Which gene are overexpressed between male and female\"
-Sample Answer3: { \"answer\": \"dge\" }
+    // Read the file
+    let ai_route_data = fs::read_to_string(ai_route).unwrap();
 
-Sample Query4: \"Which gene are housekeeping genes between male and female\"
-Sample Answer4: { \"answer\": \"dge\" } 
+    // Parse the JSON data
+    let ai_json: Value = serde_json::from_str(&ai_route_data).expect("AI JSON file does not have the correct format");
 
+    // Create a string to hold the file contents
+    let mut contents = String::from("");
 
-If a ProteinPaint dataset contains differential gene expression data then return JSON with single key, 'dge'.
-
----
-
-Survival analysis (also called time-to-event analysis or duration analysis) is a branch of statistics aimed at analyzing the duration of time from a well-defined time origin until one or more events happen, called survival times or duration times. In other words, in survival analysis, we are interested in a certain event and want to analyze the time until the event happens. Generally in survival analysis survival rates between two (or more) cohorts of patients  is compared. 
-
-There are two main methods of survival analysis:
-
-1) Kaplan-Meier (HM) analysis is a univariate test that only takes into account a single categorical variable.
-2) Cox proportional hazards model (coxph) is a multivariate test that can take into account multiple variables.
-
-   The hazard ratio (HR) is an indicator of the effect of the stimulus (e.g. drug dose, treatment) between two cohorts of patients.
-   HR = 1: No effect
-   HR < 1: Reduction in the hazard
-   HR > 1: Increase in Hazard
-
-Sample Query1: \"Compare survival rates between group A and B\"
-Sample Answer1: { \"answer\": \"survival\" }
-
-
-If a ProteinPaint dataset contains survival data then return JSON with single key, 'survival'.
-
----
-
-Next generation sequencing reads (NGS) are mapped to a human genome using alignment algorithm such as burrows-wheelers alignment algorithm. Then these reads are called using variant calling algorithms such as GATK (Genome Analysis Toolkit). However this type of analysis is too compute intensive and beyond the scope of visualization software such as ProteinPaint.
-
-If a user query asks about variant calling or mapping reads then JSON with single key, 'variant_calling'.
-
----
-
-Summary plot in ProteinPaint shows the various facets of the datasets. Show expression of a SINGLE gene or compare the expression of a SINGLE gene across two different cohorts defined by the user. It may show all the samples according to their respective diagnosis or subtypes of cancer. It is also useful for comparing and correlating different clinical variables. It can show all possible distributions, frequency of a category, overlay, correlate or cross-tabulate with another variable on top of it. If a user query asks about a SINGLE gene expression or correlating clinical variables then return JSON with single key, 'summary'.
-
-Sample Query1: \"Show all fusions for patients with age less than 30\"
-Sample Answer1: { \"answer\": \"summary\" }
-
-Sample Query2: \"List all molecular subtypes of leukemia\"
-Sample Answer2: { \"answer\": \"summary\" } 
-
-Sample Query3: \"is tp53 expression higher in men than women ?\"
-Sample Answer3: { \"answer\": \"summary\" }
-
-Sample Query4: \"Compare ATM expression between races for women greater than 80yrs\"
-Sample Answer4: { \"answer\": \"summary\" }
-
+    if let Some(object) = ai_json.as_object() {
+        for (_key, value) in object {
+            contents += &value.as_str().unwrap();
+            contents += "---"; // Adding delimiter
+        }
+    }
 
-If a query does not match any of the fields described above, then return JSON with single key, 'none'
-");
+    // Removing the last "---" characters
+    contents.pop();
+    contents.pop();
+    contents.pop();
 
     // Split the contents by the delimiter "---"
     let parts: Vec<&str> = contents.split("---").collect();
@@ -501,18 +489,18 @@ If a query does not match any of the fields described above, then return JSON wi
         rag_docs.push(part.trim().to_string())
     }
 
-    //let top_k: usize = 3;
+    //let top_k: usize = 3; // Embedding model not used currently
     // Create embeddings and add to vector store
-    let embeddings = EmbeddingsBuilder::new(embedding_model.clone())
-        .documents(rag_docs)
-        .expect("Reason1")
-        .build()
-        .await
-        .unwrap();
+    //let embeddings = EmbeddingsBuilder::new(embedding_model.clone())
+    //    .documents(rag_docs)
+    //    .expect("Reason1")
+    //    .build()
+    //    .await
+    //    .unwrap();
 
-    // Create vector store
-    let mut vector_store = InMemoryVectorStore::<String>::default();
-    InMemoryVectorStore::add_documents(&mut vector_store, embeddings);
+    //// Create vector store
+    //let mut vector_store = InMemoryVectorStore::<String>::default();
+    //InMemoryVectorStore::add_documents(&mut vector_store, embeddings);
 
     // Create RAG agent
     let agent = AgentBuilder::new(comp_model).preamble(&(String::from("Generate classification for the user query into summary, dge, hierarchical, snv_indel, cnv, variant_calling, sv_fusion and none categories. Return output in JSON with ALWAYS a single word answer { \"answer\": \"dge\" }, that is 'summary' for summary plot, 'dge' for differential gene expression, 'hierarchical' for hierarchical clustering, 'snv_indel' for SNV/Indel, 'cnv' for CNV and 'sv_fusion' for SV/fusion, 'variant_calling' for variant calling, 'surivial' for survival data, 'none' for none of the previously described categories. The summary plot list and summarizes the cohort of patients according to the user query. The answer should always be in lower case\n The options are as follows:\n") + &contents + "\nQuestion= {question} \nanswer")).temperature(temperature).additional_params(additional).build();
@@ -909,7 +897,7 @@ async fn extract_summary_information(
         .filter(|x| user_words2.contains(&x.to_lowercase()))
         .collect();
 
-    let mut summary_data_check: Option<TrainTestData> = None;
+    let mut summary_data_check: Option<TrainTestDataSummary> = None;
     for chart in ai_json.charts.clone() {
         if let Charts::Summary(traindata) = chart {
             summary_data_check = Some(traindata);
@@ -922,6 +910,7 @@ async fn extract_summary_information(
             let mut training_data: String = String::from("");
             let mut train_iter = 0;
             for ques_ans in summary_data.TrainingData {
+                let summary_answer: SummaryType = ques_ans.answer;
                 train_iter += 1;
                 training_data += "Example question";
                 training_data += &train_iter.to_string();
@@ -931,7 +920,7 @@ async fn extract_summary_information(
                 training_data += "Example answer";
                 training_data += &train_iter.to_string();
                 training_data += &":";
-                training_data += &ques_ans.answer;
+                training_data += &serde_json::to_string(&summary_answer).unwrap();
                 training_data += &"\n";
             }
 
@@ -1014,7 +1003,7 @@ struct SummaryType {
 
 impl SummaryType {
     #[allow(dead_code)]
-    pub fn sort_summarytype_struct(&mut self) {
+    pub fn sort_summarytype_struct(mut self) -> SummaryType {
         // This function is necessary for testing (test_ai.rs) to see if two variables of type "SummaryType" are equal or not. Without this a vector of two Summarytype holding the same values but in different order will be classified separately.
         self.summaryterms.sort();
 
@@ -1022,6 +1011,7 @@ impl SummaryType {
             Some(ref mut filterterms) => filterterms.sort(),
             None => {}
         }
+        self.clone()
     }
 }
 
@@ -1039,7 +1029,7 @@ impl PartialOrd for SummaryTerms {
             (SummaryTerms::clinical(_), SummaryTerms::clinical(_)) => Some(std::cmp::Ordering::Equal),
             (SummaryTerms::geneExpression(_), SummaryTerms::geneExpression(_)) => Some(std::cmp::Ordering::Equal),
             (SummaryTerms::clinical(_), SummaryTerms::geneExpression(_)) => Some(std::cmp::Ordering::Greater),
-            (SummaryTerms::geneExpression(_), SummaryTerms::clinical(_)) => Some(std::cmp::Ordering::Greater),
+            (SummaryTerms::geneExpression(_), SummaryTerms::clinical(_)) => Some(std::cmp::Ordering::Less),
         }
     }
 }
@@ -1313,10 +1303,40 @@ fn validate_summary_output(
                                     + &categorical_filter.value
                                     + &"\"},";
                                 validated_filter_terms_PP += &string_json;
-                                filter_hits += 1; // Once numeric term is also implemented, this statement will go outside the match block
                             }
-                            FilterTerm::Numeric(_numeric_term) => {} // To be implemented later
+                            FilterTerm::Numeric(numeric_filter) => {
+                                let string_json;
+                                if numeric_filter.greaterThan.is_some() && numeric_filter.lessThan.is_none() {
+                                    string_json = "{\"term\":\"".to_string()
+                                        + &numeric_filter.term
+                                        + &"\", \"gt\":\""
+                                        + &numeric_filter.greaterThan.unwrap().to_string()
+                                        + &"\"},";
+                                } else if numeric_filter.greaterThan.is_none() && numeric_filter.lessThan.is_some() {
+                                    string_json = "{\"term\":\"".to_string()
+                                        + &numeric_filter.term
+                                        + &"\", \"lt\":\""
+                                        + &numeric_filter.lessThan.unwrap().to_string()
+                                        + &"\"},";
+                                } else if numeric_filter.greaterThan.is_some() && numeric_filter.lessThan.is_some() {
+                                    string_json = "{\"term\":\"".to_string()
+                                        + &numeric_filter.term
+                                        + &"\", \"lt\":\""
+                                        + &numeric_filter.lessThan.unwrap().to_string()
+                                        + &"\", \"gt\":\""
+                                        + &numeric_filter.greaterThan.unwrap().to_string()
+                                        + &"\"},";
+                                } else {
+                                    // When both greater and less than are none
+                                    panic!(
+                                        "Numeric filter term {} is missing both greater than and less than values. One of them must be defined",
+                                        &numeric_filter.term
+                                    );
+                                }
+                                validated_filter_terms_PP += &string_json;
+                            }
                         };
+                        filter_hits += 1;
                     }
                     println!("validated_filter_terms_PP:{}", validated_filter_terms_PP);
                     if filter_hits > 0 {

package/src/manhattan_plot.rs

@@ -217,8 +217,10 @@ fn grin2_file_read(
                 Some(q) => q,
                 None => continue,
             };
+
             let q_val: f64 = match q_val_str.parse() {
                 Ok(v) if v > 0.0 => v,
+                Ok(v) if v == 0.0 => 1e-300, // Treat exact 0 as ~1e-300 so we can still show q-values that are 0 and not filter them out
                 _ => continue,
             };
             let neg_log10_q = -q_val.log10();

package/src/test_ai.rs

@@ -20,6 +20,7 @@ mod tests {
         ollama_comp_model_name: String,
         ollama_embedding_model_name: String,
         genomes: Vec<Genomes>,
+        aiRoute: String,
     }
 
     #[derive(PartialEq, Debug, Clone, schemars::JsonSchema, serde::Serialize, serde::Deserialize)]
@@ -49,7 +50,7 @@ mod tests {
 
         // Parse the JSON data
         let serverconfig: ServerConfig = serde_json::from_str(&data).expect("JSON not in serverconfig.json format");
-
+        let airoute = String::from("../../") + &serverconfig.aiRoute;
         for genome in &serverconfig.genomes {
             for dataset in &genome.datasets {
                 match &dataset.aifiles {
@@ -100,14 +101,16 @@ mod tests {
                                                 &dataset_db,
                                                 &genedb,
                                                 &ai_json,
+                                                &airoute,
                                                 testing,
                                             )
                                             .await;
-                                            let mut llm_json_value: super::super::SummaryType = serde_json::from_str(&llm_output.unwrap()).expect("Did not get a valid JSON of type {action: summary, summaryterms:[{clinical: term1}, {geneExpression: gene}], filter:[{term: term1, value: value1}]} from the LLM");
-                                            let mut expected_json_value: super::super::SummaryType = serde_json::from_str(&ques_ans.answer).expect("Did not get a valid JSON of type {action: summary, summaryterms:[{clinical: term1}, {geneExpression: gene}], filter:[{term: term1, value: value1}]} from the LLM");
+                                            let llm_json_value: super::super::SummaryType = serde_json::from_str(&llm_output.unwrap()).expect("Did not get a valid JSON of type {action: summary, summaryterms:[{clinical: term1}, {geneExpression: gene}], filter:[{term: term1, value: value1}]} from the LLM");
+                                            let sum: super::super::SummaryType = ques_ans.answer;
+                                            //println!("expected answer:{:?}", &sum);
                                             assert_eq!(
                                                 llm_json_value.sort_summarytype_struct(),
-                                                expected_json_value.sort_summarytype_struct()
+                                                sum.sort_summarytype_struct()
                                             );
                                         }
                                     }
@@ -143,14 +146,27 @@ mod tests {
                                                     &dataset_db,
                                                     &genedb,
                                                     &ai_json,
+                                                    &airoute,
                                                     testing,
                                                 )
                                                 .await;
-                                                let mut llm_json_value: super::super::SummaryType = serde_json::from_str(&llm_output.unwrap()).expect("Did not get a valid JSON of type {action: summary, summaryterms:[{clinical: term1}, {geneExpression: gene}], filter:[{term: term1, value: value1}]} from the LLM");
-                                                let mut expected_json_value: super::super::SummaryType = serde_json::from_str(&ques_ans.answer).expect("Did not get a valid JSON of type {action: summary, summaryterms:[{clinical: term1}, {geneExpression: gene}], filter:[{term: term1, value: value1}]} from the LLM");
+                                                //println!("user_input:{}", user_input);
+                                                //println!("llm_answer:{:?}", llm_output);
+                                                //println!("expected answer:{:?}", &ques_ans.answer);
+                                                let llm_json_value: super::super::SummaryType = serde_json::from_str(&llm_output.unwrap()).expect("Did not get a valid JSON of type {action: summary, summaryterms:[{clinical: term1}, {geneExpression: gene}], filter:[{term: term1, value: value1}]} from the LLM");
+                                                //println!(
+                                                //    "llm_answer:{:?}",
+                                                //    llm_json_value.clone().sort_summarytype_struct()
+                                                //);
+                                                //println!(
+                                                //    "expected answer:{:?}",
+                                                //    &expected_json_value.clone().sort_summarytype_struct()
+                                                //);
+                                                let sum: super::super::SummaryType = ques_ans.answer;
+                                                //println!("expected answer:{:?}", &sum);
                                                 assert_eq!(
                                                     llm_json_value.sort_summarytype_struct(),
-                                                    expected_json_value.sort_summarytype_struct()
+                                                    sum.sort_summarytype_struct()
                                                 );
                                             } else {
                                                 panic!("The user input is empty");