feat: adding /genes/search to annonars

src/server/actix_server/genes_search.rs

@@ -0,0 +1,176 @@
+//! Implementation of `/genes/search` that allows to search for genes by symbol etc.
+use actix_web::{
+    get,
+    web::{self, Data, Json, Path},
+    Responder,
+};
+
+use crate::server::GeneNames;
+
+use super::error::CustomError;
+use serde_with::{formats::CommaSeparator, StringWithSeparator};
+
+/// The allowed fields to search in.
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    strum::Display,
+    strum::EnumString,
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+)]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+enum Fields {
+    /// HGNC ID field
+    HgncId,
+    /// Symbol field
+    Symbol,
+    /// Name field
+    Name,
+    /// Alias symbols field
+    AliasSymbol,
+    /// Alias names field
+    AliasName,
+    /// ENSEMBL gene ID
+    EnsemblGeneId,
+    /// NCBI gene ID
+    NcbiGeneId,
+}
+
+/// Parameters for `handle`.
+#[serde_with::skip_serializing_none]
+#[serde_with::serde_as]
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
+#[serde(rename_all = "snake_case")]
+struct Request {
+    /// The string to search for.
+    pub q: String,
+    /// The fields to search in.
+    #[serde_as(as = "Option<StringWithSeparator::<CommaSeparator, Fields>>")]
+    pub fields: Option<Vec<Fields>>,
+}
+
+/// A scored result.
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
+struct Scored<T> {
+    /// The score.
+    pub score: f32,
+    /// The result.
+    pub data: T,
+}
+
+/// Result for `handle`.
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
+#[serde_with::skip_serializing_none]
+struct Container {
+    // TODO: add data version
+    /// The resulting gene information.
+    pub genes: Vec<Scored<GeneNames>>,
+}
+
+/// Query for annotations for one variant.
+#[allow(clippy::option_map_unit_fn)]
+#[get("/genes/search")]
+async fn handle(
+    data: Data<crate::server::WebServerData>,
+    _path: Path<()>,
+    query: web::Query<Request>,
+) -> actix_web::Result<impl Responder, CustomError> {
+    if query.q.len() < 2 {
+        return Ok(Json(Container {
+            // server_version: VERSION.to_string(),
+            // builder_version,
+            genes: Vec::new(),
+        }));
+    }
+
+    let genes_db = data.genes.as_ref().ok_or(CustomError::new(anyhow::anyhow!(
+        "genes database not available"
+    )))?;
+
+    let max_items = 100;
+
+    let q = &query.q;
+    let fields: Vec<Fields> = if let Some(fields) = query.fields.as_ref() {
+        fields.clone()
+    } else {
+        Vec::new()
+    };
+
+    // The fields contain the given field or are empty.
+    let fields_contains = |field: &Fields| -> bool { fields.is_empty() || fields.contains(field) };
+
+    let mut genes = genes_db
+        .gene_strings
+        .iter()
+        .map(|gn| -> Scored<GeneNames> {
+            let score = if (fields_contains(&Fields::HgncId) && &gn.hgnc_id == q)
+                || (fields_contains(&Fields::Symbol) && &gn.symbol == q)
+                || (fields_contains(&Fields::Symbol) && &gn.symbol == q)
+                || (fields_contains(&Fields::Name) && &gn.name == q)
+                || (fields_contains(&Fields::EnsemblGeneId)
+                    && gn.ensembl_gene_id.iter().any(|s| s == q))
+                || (fields_contains(&Fields::NcbiGeneId)
+                    && gn.ensembl_gene_id.iter().any(|s| s == q))
+            {
+                1f32
+            } else if fields_contains(&Fields::Symbol) && gn.symbol.contains(q) {
+                q.len() as f32 / gn.symbol.len() as f32
+            } else if fields_contains(&Fields::Name) && gn.name.contains(q) {
+                q.len() as f32 / gn.name.len() as f32
+            } else if fields_contains(&Fields::AliasSymbol)
+                && gn.alias_symbol.iter().any(|s| s.contains(q))
+            {
+                gn.alias_symbol
+                    .iter()
+                    .map(|s| {
+                        if s.contains(q) {
+                            q.len() as f32 / s.len() as f32
+                        } else {
+                            0f32
+                        }
+                    })
+                    .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+                    .unwrap_or(0f32)
+            } else if fields_contains(&Fields::AliasName)
+                && gn.alias_name.iter().any(|s| s.contains(q))
+            {
+                gn.alias_name
+                    .iter()
+                    .map(|s| {
+                        if s.contains(q) {
+                            q.len() as f32 / s.len() as f32
+                        } else {
+                            0f32
+                        }
+                    })
+                    .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
+                    .unwrap_or(0f32)
+            } else {
+                0f32
+            };
+            Scored {
+                score,
+                data: gn.clone(),
+            }
+        })
+        .filter(|s| s.score > 0.0)
+        .take(max_items)
+        .collect::<Vec<_>>();
+
+    genes.sort_by(|a, b| {
+        (b.score, &b.data.symbol)
+            .partial_cmp(&(a.score, &b.data.symbol))
+            .unwrap_or(std::cmp::Ordering::Equal)
+    });
+
+    Ok(Json(Container {
+        // server_version: VERSION.to_string(),
+        // builder_version,
+        genes,
+    }))
+}

src/server/actix_server/mod.rs

@@ -6,6 +6,7 @@ pub mod annos_variant;
 pub mod error;
 pub mod fetch;
 pub mod genes_info;
+pub mod genes_search;
 
 use actix_web::{middleware::Logger, web::Data, App, HttpServer};
 
@@ -24,7 +25,8 @@ pub async fn main(args: &Args, dbs: Data<WebServerData>) -> std::io::Result<()>
             .service(annos_variant::handle)
             .service(annos_range::handle)
             .service(annos_db_info::handle)
-            .service(genes_info::handle);
+            .service(genes_info::handle)
+            .service(genes_search::handle);
         app.wrap(Logger::default())
     })
     .bind((args.listen_host.as_str(), args.listen_port))?

src/server/mod.rs

@@ -6,9 +6,13 @@ use std::time::Instant;
 
 use clap::Parser;
 use indicatif::ParallelProgressIterator;
+use prost::Message;
 use rayon::prelude::*;
 
-use crate::common::{self, cli::GenomeRelease};
+use crate::{
+    common::{self, cli::GenomeRelease},
+    genes::pbs,
+};
 
 /// Encode annotation database.
 #[derive(
@@ -92,11 +96,32 @@ impl AnnoDb {
     }
 }
 
+/// Identifier / name information for one gene.
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+pub struct GeneNames {
+    /// HGNC gene ID.
+    pub hgnc_id: String,
+    /// HGNC gene symbol.
+    pub symbol: String,
+    /// Gene name from HGNC.
+    pub name: String,
+    /// HGNC alias symbols.
+    pub alias_symbol: Vec<String>,
+    /// HGNC alias names.
+    pub alias_name: Vec<String>,
+    /// ENSEMBL gene ID.
+    pub ensembl_gene_id: Option<String>,
+    /// NCBI gene ID.
+    pub ncbi_gene_id: Option<String>,
+}
+
 /// Gene information database.
 #[derive(Debug)]
 pub struct GeneInfoDb {
     /// The database.
     pub db: rocksdb::DBWithThreadMode<rocksdb::MultiThreaded>,
+    /// Gene information to keep in memory (for `/genes/search`).
+    pub gene_strings: Vec<GeneNames>,
 }
 
 /// Genome-release specific annotation for each database.
@@ -228,6 +253,47 @@ fn open_db(
     res
 }
 
+/// Obtain gene names from the genes RocksDB.
+fn extract_gene_names(
+    genes_db: &rocksdb::DBWithThreadMode<rocksdb::MultiThreaded>,
+) -> Result<Vec<GeneNames>, anyhow::Error> {
+    let mut result = Vec::new();
+
+    let cf_read = genes_db.cf_handle("genes").unwrap();
+    let mut iter = genes_db.raw_iterator_cf(&cf_read);
+    iter.seek(b"");
+    while iter.valid() {
+        if let Some(iter_value) = iter.value() {
+            let record = pbs::Record::decode(std::io::Cursor::new(iter_value))?;
+            let pbs::Record { hgnc, .. } = record;
+            if let Some(hgnc) = hgnc {
+                let pbs::HgncRecord {
+                    hgnc_id,
+                    symbol,
+                    name,
+                    alias_symbol,
+                    alias_name,
+                    ensembl_gene_id,
+                    entrez_id,
+                    ..
+                } = hgnc;
+                result.push(GeneNames {
+                    hgnc_id,
+                    symbol,
+                    name,
+                    alias_symbol,
+                    alias_name,
+                    ensembl_gene_id,
+                    ncbi_gene_id: entrez_id,
+                })
+            }
+        }
+        iter.next();
+    }
+
+    Ok(result)
+}
+
 /// Main entry point for `server rest` sub command.
 pub fn run(args_common: &common::cli::Args, args: &Args) -> Result<(), anyhow::Error> {
     tracing::info!("args_common = {:?}", &args_common);
@@ -255,11 +321,14 @@ pub fn run(args_common: &common::cli::Args, args: &Args) -> Result<(), anyhow::E
             "...done opening genes database in {:?}",
             before_open.elapsed()
         );
-        data.genes = Some(GeneInfoDb { db: genes });
-        tracing::info!(
-            "...done opening genes database in {:?}",
-            before_opening.elapsed()
-        );
+        tracing::info!("Building gene names...");
+        let before_open = Instant::now();
+        let gene_names = extract_gene_names(&genes)?;
+        tracing::info!("...done building genes names {:?}", before_open.elapsed());
+        data.genes = Some(GeneInfoDb {
+            db: genes,
+            gene_strings: gene_names,
+        });
     }
     // Argument lists from the command line with the corresponding database enum value.
     let paths_db_pairs = vec![
@@ -315,6 +384,16 @@ pub fn run(args_common: &common::cli::Args, args: &Args) -> Result<(), anyhow::E
         args.listen_host.as_str(),
         args.listen_port
     );
+    tracing::info!(
+        "  try: http://{}:{}/genes/search?q=BRCA",
+        args.listen_host.as_str(),
+        args.listen_port
+    );
+    tracing::info!(
+        "  try: http://{}:{}/genes/search?q=BRCA&fields=hgnc_id,ensembl_gene_id,ncbi_gene_id,symbol",
+        args.listen_host.as_str(),
+        args.listen_port
+    );
     tracing::info!(
         "  try: http://{}:{}/genes/info?hgnc_id=HGNC:12403",
         args.listen_host.as_str(),