do not initialize predictors/annotators multiple times

Author: tedil

src/annotate/seqvars/mod.rs

@@ -1331,35 +1331,6 @@ pub(crate) struct Annotator {
     annotators: Vec<AnnotatorEnum>,
 }
 
-impl Annotator {
-    pub(crate) fn consequence(&self) -> Option<&ConsequenceAnnotator> {
-        for annotator in &self.annotators {
-            if let AnnotatorEnum::Consequence(a) = annotator {
-                return Some(a);
-            }
-        }
-        None
-    }
-
-    pub(crate) fn frequencies(&self) -> Option<&FrequencyAnnotator> {
-        for annotator in &self.annotators {
-            if let AnnotatorEnum::Frequency(a) = annotator {
-                return Some(a);
-            }
-        }
-        None
-    }
-
-    pub(crate) fn clinvar(&self) -> Option<&ClinvarAnnotator> {
-        for annotator in &self.annotators {
-            if let AnnotatorEnum::Clinvar(a) = annotator {
-                return Some(a);
-            }
-        }
-        None
-    }
-}
-
 #[derive(Debug)]
 pub struct FrequencyAnnotator {
     db: DBWithThreadMode<MultiThreaded>,
@@ -1997,7 +1968,6 @@ pub(crate) fn setup_seqvars_annotator(
     assembly: Option<Assembly>,
 ) -> Result<Annotator, Error> {
     let mut annotators = vec![];
-    let pb_assembly = assembly.as_ref().and_then(proto_assembly_from);
 
     // Add the frequency annotator if requested.
     if let Some(rocksdb_path) = &sources.frequencies {
@@ -2037,29 +2007,7 @@ pub(crate) fn setup_seqvars_annotator(
     if let Some(tx_sources) = &sources.transcripts {
         tracing::info!("Opening transcript database(s)");
 
-        // Filter out any transcript databases that do not match the requested assembly.
-        let check_assembly = |db: &TxSeqDatabase, assembly: crate::pbs::txs::Assembly| {
-            db.source_version
-                .iter()
-                .map(|s| s.assembly)
-                .any(|a| a == i32::from(assembly))
-        };
-        let databases = tx_sources
-            .iter()
-            .enumerate()
-            .map(|(i, path)| (i, load_tx_db(path)))
-            .filter_map(|(i, txdb)| match txdb {
-                Ok(db) => match pb_assembly {
-                    Some(assembly) if check_assembly(&db, assembly) => Some(Ok(db)),
-                    Some(_) => {
-                        tracing::info!("Skipping transcript database {} as its version {:?} does not support the requested assembly ({:?})", &tx_sources[i], &db.source_version, &assembly);
-                        None
-                    },
-                    None => Some(Ok(db)),
-                },
-                Err(_) => Some(txdb),
-            })
-            .collect::<anyhow::Result<Vec<_>>>()?;
+        let databases = load_transcript_dbs_for_assembly(tx_sources, assembly)?;
 
         if databases.is_empty() {
             tracing::warn!("No suitable transcript databases found for requested assembly {:?}, therefore no consequence prediction will occur.", &assembly);
@@ -2080,6 +2028,38 @@ pub(crate) fn setup_seqvars_annotator(
     Ok(annotator)
 }
 
+pub(crate) fn load_transcript_dbs_for_assembly(
+    tx_sources: &Vec<String>,
+    assembly: Option<Assembly>,
+) -> Result<Vec<TxSeqDatabase>, Error> {
+    let pb_assembly = assembly.as_ref().and_then(proto_assembly_from);
+
+    // Filter out any transcript databases that do not match the requested assembly.
+    let check_assembly = |db: &TxSeqDatabase, assembly: crate::pbs::txs::Assembly| {
+        db.source_version
+            .iter()
+            .map(|s| s.assembly)
+            .any(|a| a == i32::from(assembly))
+    };
+    let databases = tx_sources
+        .iter()
+        .enumerate()
+        .map(|(i, path)| (i, load_tx_db(path)))
+        .filter_map(|(i, txdb)| match txdb {
+            Ok(db) => match pb_assembly {
+                Some(assembly) if check_assembly(&db, assembly) => Some(Ok(db)),
+                Some(_) => {
+                    tracing::info!("Skipping transcript database {} as its version {:?} does not support the requested assembly ({:?})", &tx_sources[i], &db.source_version, &assembly);
+                    None
+                },
+                None => Some(Ok(db)),
+            },
+            Err(_) => Some(txdb),
+        })
+        .collect::<anyhow::Result<Vec<_>>>()?;
+    Ok(databases)
+}
+
 /// Create for all alternate alleles from the given VCF record.
 pub fn from_vcf_allele(value: &noodles::vcf::variant::RecordBuf, allele_no: usize) -> keys::Var {
     let chrom = value.reference_sequence_name().to_string();

src/server/run/actix_server/frequencies.rs

@@ -28,8 +28,6 @@ pub(crate) struct FrequencyQuery {
     pub reference: String,
     /// SPDI insertion.
     pub alternative: String,
-    /// Optionally, the HGNC ID of the gene to limit to.
-    pub hgnc_id: Option<String>,
 }
 
 /// One entry in `FrequencyResponse`.
@@ -112,7 +110,6 @@ async fn handle_impl(
         position,
         reference,
         alternative,
-        hgnc_id,
     } = query.clone().into_inner();
 
     let annotator = data

src/server/run/mod.rs

@@ -1,6 +1,9 @@
 use crate::annotate::cli::{Sources, TranscriptSettings};
 use crate::annotate::seqvars::csq::ConfigBuilder;
-use crate::annotate::seqvars::{setup_seqvars_annotator, FrequencyAnnotator};
+use crate::annotate::seqvars::{
+    load_transcript_dbs_for_assembly, ConsequenceAnnotator, FrequencyAnnotator,
+};
+use crate::db::merge::merge_transcript_databases;
 use crate::{
     annotate::{
         seqvars::csq::ConsequencePredictor as SeqvarConsequencePredictor,
@@ -182,28 +185,37 @@ pub async fn run(args_common: &crate::common::Args, args: &Args) -> Result<(), a
         tracing::info!("  - loading genome release {:?}", genome_release);
         let assembly = genome_release.into();
 
-        let annotator =
-            setup_seqvars_annotator(&args.sources, &args.transcript_settings, Some(assembly))?;
-        if let Some(seqvars_csq_predictor) = annotator.consequence().map(|a| &a.predictor) {
-            let config = ConfigBuilder::default()
-                .report_most_severe_consequence_by(
-                    args.transcript_settings.report_most_severe_consequence_by,
-                )
-                .transcript_source(args.transcript_settings.transcript_source)
-                .build()?;
-
-            let provider = seqvars_csq_predictor.provider.clone();
-            data.provider.insert(genome_release, provider.clone());
+        if let Some(tx_db_paths) = args.sources.transcripts.as_ref() {
             tracing::info!("  - building seqvars predictors");
-            data.seqvars_predictors.insert(
-                genome_release,
-                SeqvarConsequencePredictor::new(provider.clone(), config),
-            );
-            tracing::info!("  - building strucvars predictors");
-            data.strucvars_predictors.insert(
-                genome_release,
-                StrucvarConsequencePredictor::new(provider.clone(), assembly),
-            );
+            let tx_dbs = load_transcript_dbs_for_assembly(tx_db_paths, Some(assembly))?;
+            if tx_dbs.is_empty() {
+                tracing::warn!(
+                    "No transcript databases loaded, respective endpoint will be unavailable."
+                );
+            } else {
+                let tx_db = merge_transcript_databases(tx_dbs)?;
+                let annotator =
+                    ConsequenceAnnotator::from_db_and_settings(tx_db, &args.transcript_settings)?;
+                let config = ConfigBuilder::default()
+                    .report_most_severe_consequence_by(
+                        args.transcript_settings.report_most_severe_consequence_by,
+                    )
+                    .transcript_source(args.transcript_settings.transcript_source)
+                    .build()?;
+
+                let provider = annotator.predictor.provider.clone();
+                data.provider.insert(genome_release, provider.clone());
+                data.seqvars_predictors.insert(
+                    genome_release,
+                    SeqvarConsequencePredictor::new(provider.clone(), config),
+                );
+
+                tracing::info!("  - building strucvars predictors");
+                data.strucvars_predictors.insert(
+                    genome_release,
+                    StrucvarConsequencePredictor::new(provider.clone(), assembly),
+                );
+            }
         } else {
             tracing::warn!(
                 "No predictors for genome release {:?}, respective endpoint will be unavailable.",