scout-browser 4.95.0__py3-none-any.whl → 4.97.0__py3-none-any.whl

scout/demo/rnafusion.load_config.yaml

@@ -22,3 +22,4 @@ RNAfusion_inspector_research: scout/demo/rnafusion_inspector_example.html
 analysis_date: 2022-11-02 14:00:46
 human_genome_build: '38'
 track: cancer
+status: 'prioritized'

scout/exceptions/database.py

@@ -1,5 +1,5 @@
 """The following exceptions follow PEP249:
-    https://www.python.org/dev/peps/pep-0249
+https://www.python.org/dev/peps/pep-0249
 """
 
 

scout/load/all.py

@@ -1,9 +1,8 @@
 # -*- coding: utf-8 -*-
 import logging
 
-from scout.constants import FILE_TYPE_MAP
+from scout.constants import ORDERED_FILE_TYPE_MAP
 from scout.exceptions.config import ConfigError
-from scout.utils.sort import get_load_priority
 
 LOG = logging.getLogger(__name__)
 
@@ -55,30 +54,23 @@ def load_region(adapter, case_id, hgnc_id=None, chrom=None, start=None, end=None
         start = gene_caption["start"]
         end = gene_caption["end"]
 
-    case_file_types = set()
-
-    for file_type in FILE_TYPE_MAP:
-        if case_obj.get("vcf_files", {}).get(file_type):
-            case_file_types.add(
-                (FILE_TYPE_MAP[file_type]["variant_type"], FILE_TYPE_MAP[file_type]["category"])
-            )
-
-    for variant_type, category in sorted(
-        case_file_types,
-        key=lambda tup: get_load_priority(variant_type=tup[0], category=tup[1]),
-    ):
+    for file_type, vcf_dict in ORDERED_FILE_TYPE_MAP.items():
+        if not case_obj.get("vcf_files", {}).get(file_type):
+            continue
+        variant_type = vcf_dict["variant_type"]
+        variant_category = vcf_dict["category"]
         if variant_type == "research" and not case_obj["is_research"]:
             continue
 
         LOG.info(
             "Load {} {} variants for case: {} region: chr {}, start {}, end {}".format(
-                category, variant_type.upper(), case_obj["_id"], chrom, start, end
+                variant_category, variant_type.upper(), case_obj["_id"], chrom, start, end
             )
         )
         adapter.load_variants(
             case_obj=case_obj,
             variant_type=variant_type,
-            category=category,
+            category=variant_category,
             chrom=chrom,
             start=start,
             end=end,

scout/models/case/case.py

@@ -37,6 +37,7 @@ individual = dict(
     tumor_type=str,
     tmb=str,
     msi=str,
+    hrd=str,
     tumor_purity=float,
     tissue_type=str,
     chromograph_images=str,  # path to image files

scout/models/case/case_loading_models.py

@@ -8,6 +8,8 @@ from os.path import abspath, dirname, exists, isabs
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
+from scout.constants import CASE_STATUSES
+
 try:
     from typing import Literal
 except ImportError:
@@ -15,7 +17,7 @@ except ImportError:
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
-from scout.constants import ANALYSIS_TYPES, FILE_TYPE_MAP, OMICS_FILE_TYPE_MAP
+from scout.constants import ANALYSIS_TYPES, ORDERED_FILE_TYPE_MAP, ORDERED_OMICS_FILE_TYPE_MAP
 from scout.exceptions import PedigreeError
 from scout.utils.date import get_date
 
@@ -52,6 +54,9 @@ CASE_FILE_PATH_CHECKS = [
     "peddy_ped",
     "peddy_ped_check",
     "peddy_sex_check",
+    "somalier_ancestry",
+    "somalier_pairs",
+    "somalier_samples",
     "smn_tsv",
     "reference_info",
     "RNAfusion_inspector",
@@ -61,8 +66,8 @@ CASE_FILE_PATH_CHECKS = [
     "rna_delivery_report",
 ]
 
-VCF_FILE_PATH_CHECKS = FILE_TYPE_MAP.keys()
-OMICS_FILE_PATH_CHECKS = OMICS_FILE_TYPE_MAP.keys()
+VCF_FILE_PATH_CHECKS = ORDERED_FILE_TYPE_MAP.keys()
+OMICS_FILE_PATH_CHECKS = ORDERED_OMICS_FILE_TYPE_MAP.keys()
 
 GENOME_BUILDS = ["37", "38"]
 TRACKS = ["rare", "cancer"]
@@ -207,6 +212,7 @@ class SampleLoader(BaseModel):
     d4_file: Optional[str] = None
     display_name: Optional[str] = None
     father: Optional[str] = None
+    hrd: Optional[str] = None
     individual_id: str = Field(alias="sample_id")
     is_sma: Optional[str] = None
     is_sma_carrier: Optional[str] = None
@@ -245,8 +251,8 @@ class SampleLoader(BaseModel):
 
     @model_validator(mode="before")
     def convert_cancer_int_values_to_str(cls, values) -> "SampleLoader":
-        """Sets 'msi' and 'msi' values for cancer cases to string. This is a required step in Pydantic2, in Pydantic1 values were just coerced from int to str."""
-        for item in ["msi", "tmb"]:
+        """Sets 'msi' 'tmb' and 'hrd' values for cancer cases to string. This is a required step in Pydantic2, in Pydantic1 values were just coerced from int to str."""
+        for item in ["msi", "tmb", "hrd"]:
             if values.get(item):
                 values[item] = str(values[item])
         return values
@@ -424,6 +430,9 @@ class CaseLoader(BaseModel):
     peddy_sex_check: Optional[str] = Field(None, alias="peddy_sex")  # Soon to be deprecated
     phenotype_groups: Optional[List[str]] = None
     phenotype_terms: Optional[List[str]] = None
+    somalier_ancestry: Optional[str] = None
+    somalier_pairs: Optional[str] = None
+    somalier_samples: Optional[str] = None
     exe_ver: Optional[str] = None
     rank_model_version: Optional[str] = None
     rank_score_threshold: Optional[int] = 0
@@ -436,6 +445,7 @@ class CaseLoader(BaseModel):
     smn_tsv: Optional[str] = None
     sv_rank_model_version: Optional[str] = None
     synopsis: Optional[Union[List[str], str]] = None
+    status: Optional[Literal[tuple(CASE_STATUSES)]] = None
     track: Literal["rare", "cancer"] = "rare"
     vcf_files: Optional[VcfFiles]
 

scout/models/managed_variant.py

@@ -1,7 +1,7 @@
-""" Managed variant
+"""Managed variant
 
-    For potentially causative variants that are not yet in ClinVar
-    and have yet not been marked causative in any existing case.
+For potentially causative variants that are not yet in ClinVar
+and have yet not been marked causative in any existing case.
 
 """
 

scout/models/omics_variant.py

@@ -1,7 +1,7 @@
-""" OMICS variant
+"""OMICS variant
 
-    For potentially causative variants that are not yet in ClinVar
-    and have yet not been marked causative in any existing case.
+For potentially causative variants that are not yet in ClinVar
+and have yet not been marked causative in any existing case.
 
 """
 

scout/parse/case.py

@@ -1,12 +1,20 @@
 import logging
+from typing import Any, Dict, Tuple
 
 from ped_parser import FamilyParser
 
-from scout.constants import PHENOTYPE_MAP, SEX_MAP
+from scout.constants import PHENOTYPE_MAP, REV_SEX_MAP, SEX_MAP
 from scout.exceptions import PedigreeError
 from scout.models.case.case_loading_models import CaseLoader
 from scout.parse.mitodel import parse_mitodel_file
-from scout.parse.peddy import parse_peddy_ped, parse_peddy_ped_check, parse_peddy_sex_check
+from scout.parse.pedqc import (
+    parse_peddy_ped,
+    parse_peddy_ped_check,
+    parse_peddy_sex_check,
+    parse_somalier_ancestry,
+    parse_somalier_pairs,
+    parse_somalier_samples,
+)
 from scout.parse.smn import parse_smn_file
 
 LOG = logging.getLogger(__name__)
@@ -19,7 +27,7 @@ def parse_case_data(**kwargs):
     on the command line. Or all the information can be specified in a config file.
     Please see Scout documentation for further instructions.
 
-    Possible keyword args:
+    Possible keyword args are formally available in the CaseLoader class, but here is a common list with explanations:
         cnv_report: Path to pdf file with CNV report
         config(dict): A yaml formatted config file
         coverage_qc_report: Path to html file with coverage and qc report
@@ -34,6 +42,7 @@ def parse_case_data(**kwargs):
         RNAfusion_report: Path to the RNA fusion report
         RNAfusion_report_research: Path to the research RNA fusion report
         smn_tsv(str): Path to an SMN tsv file
+        status(str): Optional case status ("prioritized", "inactive", "ignored", "active", "solved", "archived")
         vcf_cancer(str): Path to a vcf file
         vcf_cancer_sv(str): Path to a vcf file
         vcf_fusion(str): Path to a vcf file
@@ -73,8 +82,10 @@ def parse_case_data(**kwargs):
             except KeyError:
                 config_dict[key] = None
 
-    # This will add information from peddy to the individuals
+    # This will add pedigree qc information from Peddy and Somalier to the individuals.
+    # Let the newer Somalier have the last word if there is any disagreement
     add_peddy_information(config_dict)
+    add_somalier_information(config_dict)
 
     if config_dict.get("smn_tsv"):
         add_smn_info(config_dict)
@@ -180,7 +191,104 @@ def add_smn_info_case(case_data):
             ]:
                 ind[key] = smn_info[ind_id][key]
         except KeyError as err:
-            LOG.warning("Individual {} has no SMN info to update: {}.".format(ind_id, err))
+            LOG.warning(f"Individual {ind_id} has no SMN info to update: {err}.")
+
+
+def set_somalier_sex_check_ind(ind: Dict[str, str], sex_check: Dict[str, Dict[str, str]]):
+    """Check if Somalier has inferred the sex"""
+
+    ind_id = ind["individual_id"]
+    if ind_id in sex_check and all(
+        key in sex_check[ind_id] for key in ("sex", "original_pedigree_sex")
+    ):
+        ind["confirmed_sex"]: bool = (
+            sex_check[ind_id]["sex"] == REV_SEX_MAP[sex_check[ind_id]["original_pedigree_sex"]]
+        )
+
+
+def set_somalier_confirmed_parent(
+    analysis_inds: Dict[str, Any], ind: Dict[str, Any], ped_check: Dict[Tuple, Any]
+):
+    """Check if Somalier confirmed parental relations.
+    First, check that we are looking at individual with parents.
+    Double-check that the child/parent pair is in somalier data and set ok.
+    If we demand Somalier be run with "relate --infer" we can skip this.
+    """
+
+    ind_id = ind["individual_id"]
+    for parent in ["mother", "father"]:
+        parent_id = ind[parent]
+        if parent_id == "0":
+            continue
+
+        for pair in ped_check:
+            if ind_id not in pair or parent_id not in pair:
+                continue
+            if (
+                ped_check[pair]["relatedness"] > 0.32
+                and ped_check[pair]["relatedness"] < 0.67
+                and ped_check[pair]["ibs0"] / ped_check[pair]["ibs2"] < 0.014
+            ):
+                analysis_inds[parent_id]["confirmed_parent"] = True
+                continue
+            # else if parent confirmation failed
+            analysis_inds[parent_id]["confirmed_parent"] = False
+
+
+def set_somalier_sex_and_relatedness_checks(
+    case_config: dict,
+    ped_check: Dict[Tuple, Any],
+    sex_check: Dict[str, Dict],
+    ancestry_info: Dict[str, Dict],
+):
+    """
+    Update ancestry, sex and relatedness checks for individuals in case config based on parsed Somalier file content.
+    """
+    analysis_inds = {}
+    for ind in case_config["individuals"]:
+        ind_id = ind["individual_id"]
+        analysis_inds[ind_id] = ind
+
+    for ind_id in analysis_inds:
+        ind = analysis_inds[ind_id]
+        # Check if Somalier has inferred the ancestry
+        if ind_id in ancestry_info:
+            ind["predicted_ancestry"]: str = ancestry_info[ind_id].get(
+                "predicted_ancestry", "UNKNOWN"
+            )
+        set_somalier_sex_check_ind(ind, sex_check)
+        set_somalier_confirmed_parent(analysis_inds, ind, ped_check)
+
+
+def add_somalier_information(case_config: dict):
+    """
+    Parse any somalier files, and update ancestry, sex and relatedness checks for individuals in case config
+    based on them.
+    """
+    ped_check = {}
+    sex_check = {}
+    ancestry_info = {}
+
+    if case_config.get("somalier_pairs"):
+        with open(case_config["somalier_pairs"], "r") as file_handle:
+            for pair_info in parse_somalier_pairs(file_handle):
+                ped_check[(pair_info["sample_a"], pair_info["sample_b"])] = pair_info
+
+    if case_config.get("somalier_samples"):
+        with open(case_config["somalier_samples"], "r") as file_handle:
+            for ind_info in parse_somalier_samples(file_handle):
+                sex_check[ind_info["sample_id"]] = ind_info
+
+    if case_config.get("somalier_ancestry"):
+        with open(case_config["somalier_ancestry"], "r") as file_handle:
+            for ind_info in parse_somalier_ancestry(file_handle):
+                ancestry_info[ind_info["sample_id"]] = ind_info
+
+    if not (ped_check or sex_check or ancestry_info):
+        return
+
+    LOG.info("Adding Somalier info")
+    set_somalier_sex_and_relatedness_checks(case_config, ped_check, sex_check, ancestry_info)
 
 
 def add_peddy_information(config_data):

scout/parse/pedqc.py

@@ -0,0 +1,127 @@
+from typing import List
+
+from scout.utils.convert import convert_number, make_bool
+
+
+def tsv_to_info_dicts(
+    lines: List[str], separator: str = "\t", number_keys: List[str] = [], bool_keys: List[str] = []
+) -> List[dict]:
+    """Parse a tsv (or csv with "," as separator) file to a list of dicts, with the header fields as dict keys,
+    column values as dict values, and each list item one such dict for each row.
+    The number_keys and bool_keys are lists of key names to attempt to explicitly coerce values into number or bool before return.
+    """
+    info_dicts = []
+    for i, line in enumerate(lines):
+        line = line.rstrip()
+        if i == 0:
+            header = line.lstrip("#").split(separator)
+            continue
+        info_dict = dict(zip(header, line.split(separator)))
+        for number_key in number_keys:
+            if number_key in info_dict:
+                info_dict[number_key] = convert_number(info_dict[number_key])
+        for bool_key in bool_keys:
+            if bool_key in info_dict:
+                info_dict[bool_key] = make_bool(info_dict.get(bool_key))
+        info_dicts.append(info_dict)
+
+    return info_dicts
+
+
+def parse_peddy_ped(lines: List[str]) -> List[dict]:
+    """Parse a peddy.ped file
+
+    ancestry-prediction: one of AFR AMR EAS EUR SAS UNKNOWN
+    PC1/PC2/PC3/PC4: the first 4 values after this sample was
+                    projected onto the thousand genomes principal components.
+
+    idr_baf: inter-decile range (90th percentile - 10th percentile)
+             of b-allele frequency. We make a distribution of all sites of
+             alts / (ref + alts) and then report the difference between the
+             90th and the 10th percentile.
+             Large values indicated likely sample contamination.
+    """
+    return tsv_to_info_dicts(
+        lines,
+        "\t",
+        number_keys=["PC1", "PC2", "PC3", "het_call_rate", "het_idr_baf", "het_mean_depth"],
+    )
+
+
+def parse_peddy_ped_check(lines: List[str]) -> List[dict]:
+    """Parse a .ped_check.csv file
+
+    The following keys are explicitly coerced upon insertion into the returned dicts
+            hets_a  - the number of sites at which sample_a was heterozygous
+            hets_b  - the number of sites at which sample_b was heterozygous
+            ibs0    - the number of sites at which the 2 samples shared no alleles
+                    (should approach 0 for parent-child pairs).
+            ibs2    - the number of sites and which the 2 samples where both
+                    hom-ref, both het, or both hom-alt.
+            n       - the number of sites that was used to predict the relatedness.
+            rel     - the relatedness reported in the ped file.
+            pedigree_relatedness - the relatedness reported in the ped file.
+            rel_difference - difference between the preceding 2 columns.
+            shared_hets - the number of sites at which both samples were hets.
+
+            pedigree_parents - boolean indicating that this pair is a parent-child pair
+                    according to the ped file.
+            predicted_parents - boolean indicating that this pair is expected to be a parent-child
+                    pair according to the ibs0 (< 0.012) calculated from the genotypes.
+            parent_error - boolean indicating that the preceding 2 columns do not match
+            sample_duplication_error - boolean indicating that rel > 0.75 and ibs0 < 0.012
+    """
+    return tsv_to_info_dicts(
+        lines,
+        ",",
+        number_keys=[
+            "hets_a",
+            "hets_b",
+            "ibs0",
+            "ibs2",
+            "n",
+            "rel",
+            "pedigree_relatedness",
+            "rel_difference",
+            "shared_hets",
+        ],
+        bool_keys=[
+            "pedigree_parents",
+            "predicted_parents",
+            "parent_error",
+            "sample_duplication_error",
+        ],
+    )
+
+
+def parse_peddy_sex_check(lines: List[str]) -> List[dict]:
+    """Parse a .ped_check.csv file
+
+    Type coerce the following keys for each dict in the returned sex_check dict:
+        error: boolean indicating whether there is a mismatch between chr genotypes and ped sex
+        hom_alt_count: number of homozygous-alternate calls
+        hom_ref_count: number of homozygous-reference calls
+        het_count:  number of heterozygote calls
+        het_ratio: ratio of het_count / hom_alt_count. Low for males, high for females
+    """
+    return tsv_to_info_dicts(
+        lines,
+        ",",
+        number_keys=["hom_alt_count", "hom_ref_count", "het_count", "het_ratio"],
+        bool_keys=["error"],
+    )
+
+
+def parse_somalier_pairs(lines: List[str]) -> List[dict]:
+    """Parse a Somalier pairs tsv file"""
+    return tsv_to_info_dicts(lines, "\t", ["relatedness", "ibs0", "ibs2"])
+
+
+def parse_somalier_samples(lines: List[str]) -> List[dict]:
+    """Parse a Somalier samples tsv file"""
+    return tsv_to_info_dicts(lines, "\t")
+
+
+def parse_somalier_ancestry(lines: List[str]) -> List[dict]:
+    """Parse a Somalier ancestry tsv file"""
+    return tsv_to_info_dicts(lines, "\t")

scout/parse/variant/frequency.py

@@ -92,10 +92,10 @@ def parse_frequency(variant, info_key):
         info_key(str)
 
     Returns:
-        frequency(float): or None if frequency does not exist
+        frequency(float): or None if frequency does not exist (or is ".", "0", or "-1")
     """
     raw_annotation = variant.INFO.get(info_key)
-    raw_annotation = None if raw_annotation == "." else raw_annotation
+    raw_annotation = None if raw_annotation in [".", "-1", -1, 0, "0"] else raw_annotation
     frequency = float(raw_annotation) if raw_annotation else None
     return frequency
 
@@ -152,11 +152,14 @@ def parse_sv_frequency(variant, info_key):
     These have to be treated separately since some of them are not actually frequencies(float) but
     occurences(int)
     """
-    value = variant.INFO.get(info_key, 0)
-    if any([float_str in info_key.upper() for float_str in ["AF", "FRQ"]]):
-        value = float(value)
+    raw_value = variant.INFO.get(info_key, 0)
+    if raw_value in [".", "-1", -1, 0, "0"]:
+        return None
+
+    if any(float_str in info_key.upper() for float_str in ["AF", "FRQ"]):
+        value = float(raw_value)
     else:
-        value = int(value)
+        value = int(raw_value)
     if value > 0:
         return value
     return None

scout/parse/variant/variant.py

@@ -27,14 +27,14 @@ LOG = logging.getLogger(__name__)
 
 def parse_variant(
     variant: Variant,
-    case,
-    variant_type="clinical",
-    rank_results_header=None,
-    vep_header=None,
-    individual_positions=None,
-    category=None,
-    local_archive_info=None,
-):
+    case: dict,
+    variant_type: str = "clinical",
+    rank_results_header: list = None,
+    vep_header: list = None,
+    individual_positions: dict = None,
+    category: str = None,
+    local_archive_info: dict = None,
+) -> dict:
     """Return a parsed variant
 
         Get all the necessary information to build a variant object
@@ -183,10 +183,63 @@ def parse_variant(
 
     parsed_variant["frequencies"] = frequencies
 
-    # loqus archive frequencies
+    set_loqus_archive_frequencies(parsed_variant, variant, local_archive_info)
+
+    set_severity_predictions(parsed_variant, variant, parsed_transcripts)
+
+    ###################### Add conservation ######################
+    parsed_variant["conservation"] = parse_conservations(variant, parsed_transcripts)
+
+    parsed_variant["callers"] = parse_callers(variant, category=category)
+    set_rank_result(parsed_variant, variant, rank_results_header)
+
+    ##################### Add type specific #####################
+    set_sv_specific_annotations(parsed_variant, variant)
+
+    set_mei_specific_annotations(parsed_variant, variant)
+
+    set_cancer_specific_annotations(parsed_variant, variant)
+
+    remove_nonetype(parsed_variant)
+    return parsed_variant
+
+
+def set_mei_specific_annotations(parsed_variant: dict, variant: dict):
+    """Add MEI specific annotations"""
+    if parsed_variant.get("category") in ["mei"]:
+        mei_frequencies = parse_mei_frequencies(variant)
+        for key in mei_frequencies:
+            parsed_variant["frequencies"][key] = mei_frequencies[key]
+
+
+def set_cancer_specific_annotations(parsed_variant: dict, variant: dict):
+    """
+    ###################### Add Cancer specific annotations ######################
+    # MSK_MVL indicates if variants are in the MSK managed variant list
+    # https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5437632/
+    """
+    if variant.INFO.get("MSK_MVL"):
+        parsed_variant["mvl_tag"] = True
+
+
+def set_sv_specific_annotations(parsed_variant: dict, variant: dict):
+    """
+    Add SV specific annotations
+    """
+    if parsed_variant.get("category") in ["sv", "cancer_sv"]:
+        sv_frequencies = parse_sv_frequencies(variant)
+        for key in sv_frequencies:
+            parsed_variant["frequencies"][key] = sv_frequencies[key]
+
+
+def set_loqus_archive_frequencies(parsed_variant: dict, variant: dict, local_archive_info: dict):
+    """
+    loqusdb archive frequencies
+    Fist, RD germline, for MIP and Balsamic
+    Then, Cancer (Balsamic) Germline and Somatic loqus archives
+    SNVs contain INFO field Obs, SVs contain clinical_genomics_loqusObs
+    """
 
-    # RD germline, for MIP and Balsamic
-    # SNVs contain INFO field Obs, SVs contain clinical_genomics_loqusObs
     local_obs_old = (
         variant.INFO.get("Obs")
         or variant.INFO.get("clinical_genomics_loqusObs")
@@ -203,7 +256,6 @@ def parse_variant(
     parsed_variant["local_obs_old_freq"] = call_safe(float, local_frq_old)
     set_local_archive_info(parsed_variant, local_archive_info)
 
-    # Cancer (Balsamic) Germline and Somatic loqus archives
     parsed_variant["local_obs_cancer_germline_old"] = call_safe(
         int, variant.INFO.get("Cancer_Germline_Obs")
     )
@@ -224,7 +276,12 @@ def parse_variant(
         float, variant.INFO.get("Cancer_Somatic_Frq")
     )
 
-    ###################### Add severity predictions ######################
+
+def set_severity_predictions(parsed_variant: dict, variant: dict, parsed_transcripts: dict):
+    """
+    Set severity predictions on parsed variant.
+    """
+
     parsed_variant["cadd_score"] = parse_cadd(variant, parsed_transcripts)
     parsed_variant["spidex"] = call_safe(float, variant.INFO.get("SPIDEX"))
 
@@ -234,31 +291,6 @@ def parse_variant(
         )  # This is actually the value of REVEL_rankscore
         parsed_variant["revel"] = get_highest_revel_score(parsed_transcripts)
 
-    ###################### Add conservation ######################
-    parsed_variant["conservation"] = parse_conservations(variant, parsed_transcripts)
-
-    parsed_variant["callers"] = parse_callers(variant, category=category)
-    set_rank_result(parsed_variant, variant, rank_results_header)
-
-    ###################### Add SV specific annotations ######################
-    sv_frequencies = parse_sv_frequencies(variant)
-    for key in sv_frequencies:
-        parsed_variant["frequencies"][key] = sv_frequencies[key]
-
-    ###################### Add MEI specific annotations #####################
-    mei_frequencies = parse_mei_frequencies(variant)
-    for key in mei_frequencies:
-        parsed_variant["frequencies"][key] = mei_frequencies[key]
-
-    ###################### Add Cancer specific annotations ######################
-    # MSK_MVL indicates if variants are in the MSK managed variant list
-    # https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5437632/
-    if variant.INFO.get("MSK_MVL"):
-        parsed_variant["mvl_tag"] = True
-
-    remove_nonetype(parsed_variant)
-    return parsed_variant
-
 
 def get_highest_revel_score(parsed_transcripts: List[dict]) -> Optional[float]:
     """Retrieve the highest REVEL_score value from parsed variant transcripts."""
@@ -484,7 +516,7 @@ def set_fusion_info(variant: Variant, parsed_variant: Dict[str, Any]):
 
 
 def add_gene_and_transcript_info_for_fusions(
-    parsed_variant: Dict[str, Any]
+    parsed_variant: Dict[str, Any],
 ) -> List[Optional[Dict]]:
     """Add gene and transcript info for fusions. Return list of parsed
     transcripts for later use in parsing.

scout/server/app.py

@@ -13,6 +13,8 @@ from flask_login import current_user
 from markdown import markdown as python_markdown
 from markupsafe import Markup
 
+from scout import __version__
+from scout.constants import SPIDEX_HUMAN
 from scout.log import init_log
 
 from . import extensions
@@ -47,6 +49,7 @@ def create_app(config_file=None, config=None):
     app = Flask(__name__)
     CORS(app)
     app.jinja_env.add_extension("jinja2.ext.do")
+    app.jinja_env.globals["SCOUT_VERSION"] = __version__
 
     app.config.from_pyfile("config.py")  # Load default config file
     if (
@@ -199,6 +202,17 @@ def register_filters(app):
             return "{:,}".format(int(value)).replace(",", " ")
         return value
 
+    @app.template_filter()
+    def spidex_human(spidex):
+        """Translate SPIDEX annotation to human readable string."""
+        if spidex is None:
+            return "not_reported"
+        if abs(spidex) < SPIDEX_HUMAN["low"]["pos"][1]:
+            return "low"
+        if abs(spidex) < SPIDEX_HUMAN["medium"]["pos"][1]:
+            return "medium"
+        return "high"
+
     @app.template_filter()
     def human_decimal(number, ndigits=4):
         """Return a standard representation of a decimal number.