scout-browser 4.94.1__py3-none-any.whl → 4.96.0__py3-none-any.whl

scout/adapter/mongo/case.py

@@ -982,7 +982,6 @@ class CaseHandler(object):
                         variant_type=variant_type,
                         category=category,
                     )
-                # add variants
                 self.load_variants(
                     case_obj=case_obj,
                     variant_type=variant_type,
@@ -994,33 +993,34 @@ class CaseHandler(object):
                     ),
                 )
 
-        except (IntegrityError, ValueError, ConfigError, KeyError) as error:
-            LOG.warning(error)
-
-        self._load_omics_variants(case_obj, build=genome_build, update=update)
-
-        if existing_case:
-            self.update_case_data_sharing(old_case=existing_case, new_case=case_obj)
-            case_obj["rerun_requested"] = False
-            if case_obj["status"] in ["active", "archived"]:
-                case_obj["status"] = "inactive"
-
-            case_obj["variants_stats"] = self.case_variants_count(
-                case_id=case_obj["_id"],
-                institute_id=institute_obj["_id"],
-                force_update_case=True,
-            )
+                self._load_omics_variants(case_obj, build=genome_build, update=update)
 
-            self.update_case_cli(case_obj, institute_obj)
-            # update Sanger status for the new inserted variants
-            self.update_case_sanger_variants(institute_obj, case_obj, old_sanger_variants)
+        except (IntegrityError, ValueError, ConfigError, KeyError) as error:
+            LOG.exception(error)
+            raise error
+        else:
+            if not existing_case:
+                LOG.info("Loading case %s into database", case_obj["display_name"])
+                self.add_case(case_obj, institute_obj)
+        finally:
+            if existing_case:
+                self.update_case_data_sharing(old_case=existing_case, new_case=case_obj)
+                case_obj["rerun_requested"] = False
+                if case_obj["status"] in ["active", "archived"]:
+                    case_obj["status"] = "inactive"
+
+                case_obj["variants_stats"] = self.case_variants_count(
+                    case_id=case_obj["_id"],
+                    institute_id=institute_obj["_id"],
+                    force_update_case=True,
+                )
 
-            if keep_actions and old_evaluated_variants:
-                self.update_variant_actions(institute_obj, case_obj, old_evaluated_variants)
+                self.update_case_cli(case_obj, institute_obj)
+                # update Sanger status for the new inserted variants
+                self.update_case_sanger_variants(institute_obj, case_obj, old_sanger_variants)
 
-        else:
-            LOG.info("Loading case %s into database", case_obj["display_name"])
-            self.add_case(case_obj, institute_obj)
+                if keep_actions and old_evaluated_variants:
+                    self.update_variant_actions(institute_obj, case_obj, old_evaluated_variants)
 
         return case_obj
 
@@ -1146,6 +1146,7 @@ class CaseHandler(object):
                 "RNAfusion_report": case_obj.get("RNAfusion_report"),
                 "RNAfusion_report_research": case_obj.get("RNAfusion_report_research"),
                 "rna_delivery_report": case_obj.get("rna_delivery_report"),
+                "scout_load_version": case_obj.get("scout_load_version"),
                 "smn_tsv": case_obj.get("smn_tsv"),
                 "status": case_obj.get("status"),
                 "sv_rank_model_version": case_obj.get("sv_rank_model_version"),

scout/adapter/mongo/hgnc.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict
+from typing import Dict, Set
 
 import intervaltree
 from pymongo.errors import BulkWriteError, DuplicateKeyError
@@ -126,6 +126,10 @@ class GeneHandler(object):
 
         return None
 
+    def hgnc_ids(self) -> Set[int]:
+        """Returns all HGNC IDs present in the hgnc_gene collection."""
+        return set(self.hgnc_collection.distinct("hgnc_id"))
+
     def hgnc_genes(self, hgnc_symbol, build="37", search=False):
         """Fetch all hgnc genes that match a hgnc symbol
 

scout/adapter/mongo/managed_variant.py

@@ -180,10 +180,12 @@ class ManagedVariantHandler(object):
                 }
 
             if "position" in query_options:
-                query["end"] = {"$gte": int(query_options["position"])}
+                position = max(int(query_options["position"]), 1)
+                query["end"] = {"$gte": position}
 
             if "end" in query_options:
-                query["position"] = {"$lte": int(query_options["end"])}
+                end = max(int(query_options["end"]), 1)
+                query["position"] = {"$lte": end}
 
             if "sub_category" in query_options:
                 query["sub_category"] = {"$in": query_options["sub_category"]}

scout/adapter/mongo/query.py

@@ -469,8 +469,10 @@ class QueryHandler(object):
             mongo_query(dict): returned object contains coordinate filters
 
         """
-        mongo_query["position"] = {"$lte": int(query["end"])}
-        mongo_query["end"] = {"$gte": int(query["start"])}
+        start_pos = max(int(query["start"]), 1)
+        end_pos = max(int(query["end"]), 1)
+        mongo_query["position"] = {"$lte": end_pos}
+        mongo_query["end"] = {"$gte": start_pos}
 
         return mongo_query
 
@@ -559,8 +561,8 @@ class QueryHandler(object):
             query.get("start") is not None and query.get("end") is not None
         ):  # query contains full coordinates
             chrom = query["chrom"]
-            start = int(query["start"])
-            end = int(query["end"])
+            start = max(int(query["start"]), 1)
+            end = max(int(query["end"]), 1)
             coordinate_query = self.get_position_query(chrom=chrom, start=start, end=end)
         else:  # query contains only chromosome info
             coordinate_query = {

scout/adapter/mongo/variant.py

@@ -491,12 +491,17 @@ class VariantHandler(VariantLoader):
         if len(affected_ids) == 0:
             return []
         filters["case_id"] = case_obj["_id"]
-        filters["samples"] = {
-            "$elemMatch": {
-                "sample_id": {"$in": affected_ids},
-                "genotype_call": {"$regex": CARRIER},
-            }
-        }
+        filters["$or"] = [
+            {"samples": {"$size": 1}},  # Condition for samples with exactly one element
+            {
+                "samples": {
+                    "$elemMatch": {  # Condition for samples with more than one element: individual/sample should be carrier
+                        "sample_id": {"$in": affected_ids},
+                        "genotype_call": {"$regex": CARRIER},
+                    }
+                }
+            },
+        ]
 
         if limit_genes:
             filters["genes.hgnc_id"] = {"$in": limit_genes}

scout/build/case.py

@@ -1,6 +1,7 @@
 import logging
 from datetime import datetime
 from typing import Dict
+from scout import __version__
 
 from scout.constants import CUSTOM_CASE_REPORTS, PHENOTYPE_GROUPS
 from scout.exceptions import ConfigError, IntegrityError
@@ -154,6 +155,7 @@ def build_case(case_data, adapter):
     now = datetime.now()
     case_obj["created_at"] = now
     case_obj["updated_at"] = now
+    case_obj["scout_load_version"] = __version__
 
     if case_data.get("suspects"):
         case_obj["suspects"] = case_data["suspects"]
@@ -162,7 +164,7 @@ def build_case(case_data, adapter):
 
     case_obj["synopsis"] = case_data.get("synopsis", "")
 
-    case_obj["status"] = "inactive"
+    case_obj["status"] = case_data.get("status") or "inactive"
     case_obj["is_research"] = False
     case_obj["research_requested"] = False
     case_obj["rerun_requested"] = False

scout/build/panel.py

@@ -42,7 +42,7 @@ def build_gene(gene_info: dict, adapter) -> dict:
 
     # Add boolean flags
     gene_obj.update(
-        {key: True for key in ["reduced_penetrance", "mosaicism"] if gene_info.get(key)}
+        {key: gene_info.get(key) for key in ["reduced_penetrance", "mosaicism"] if key in gene_info}
     )
 
     # Handle inheritance models

scout/constants/acmg.py

@@ -309,48 +309,55 @@ ACMG_CRITERIA["benign impact"] = OrderedDict(
 
 ACMG_POTENTIAL_CONFLICTS = [
     (
-        "PVS1",
-        "PM4",
+        {"PVS1", "PM4"},
         "Use of PVS1 and PM4 together risks double-counting evidence (Tayoun et al 2019).",
     ),
     (
-        "PVS1",
-        "PM1",
+        {"PVS1", "PM1"},
         "Use of PVS1 and PM1 together is not recommended (Durkie et al 2024).",
     ),
     (
-        "PVS1",
-        "PP2",
+        {"PVS1", "PP2"},
         "Use of PVS1 and PP2 together is not recommended (Durkie et al 2024).",
     ),
     (
-        "PVS1",
-        "PS3",
+        {"PVS1", "PS3"},
         "Note that for RNA PS3 should only be taken with PVS1 for well established functional assays, not splicing alone (Walker 2023).",
     ),
     (
-        "PS1",
-        "PM4",
+        {"PS1", "PM4"},
         "Use of PS1 and PM4 together is not recommended (Durkie et al 2024).",
     ),
     (
-        "PS1",
-        "PM5",
+        {"PS1", "PM5"},
         "Use of PS1 and PM5 together conflicts with original definition (Richards et al 2015).",
     ),
     (
-        "PS1",
-        "PP3",
+        {"PS1", "PP3"},
         "Use of PS1 and PP3 together risks double-counting evidence (Tayoun et al 2019).",
     ),
     (
-        "PS2",
-        "PM6",
+        {"PS2", "PM6"},
         "Use of PS2 and PM6 together conflicts with original definition (Richards et al 2015).",
     ),
     (
-        "PM1",
-        "PP2",
+        {"PM1", "PP2"},
         "Avoid double-counting evidence for constraints in both PM1 and PP2 (Durkie et al 2024).",
     ),
+    (
+        {"PP1", "PP4"},
+        "When applying phenotype specificity and segregation data together, a point-system is available from ClinGen SVI (Biesecker et al 2024).",
+    ),
+    (
+        {"BS4", "PP4"},
+        "When applying phenotype specificity and segregation data together, a point-system is available from ClinGen SVI (Biesecker et al 2024).",
+    ),
+    (
+        {"PS2", "PP4"},
+        "Consider using PS2 without the PP4 criterion, based on the SVI Recommendation for de novo Criteria (PS2 & PM6).",
+    ),
+    (
+        {"PM6", "PP4"},
+        "Consider using PM6 without the PP4 criterion, based on the SVI Recommendation for de novo Criteria (PS2 & PM6).",
+    ),
 ]

scout/constants/gene_tags.py

@@ -33,20 +33,30 @@ INHERITANCE_PALETTE = {
     "other": {"bgcolor": "bg-light", "text_color": "text-dark"},
 }
 
-INCOMPLETE_PENETRANCE_MAP = {"unknown": None, "Complete": None, "Incomplete": True}
+INCOMPLETE_PENETRANCE_MAP = {"unknown": None, "None": None, "Complete": False, "Incomplete": True}
 
 MODELS_MAP = {
-    "monoallelic_not_imprinted": ["AD"],
-    "monoallelic_maternally_imprinted": ["AD"],
-    "monoallelic_paternally_imprinted": ["AD"],
-    "monoallelic": ["AD"],
-    "biallelic": ["AR"],
-    "monoallelic_and_biallelic": ["AD", "AR"],
-    "monoallelic_and_more_severe_biallelic": ["AD", "AR"],
-    "xlinked_biallelic": ["XR"],
-    "xlinked_monoallelic": ["XD"],
-    "mitochondrial": ["MT"],
-    "unknown": [],
+    "MONOALLELIC, autosomal or pseudoautosomal, NOT imprinted": ["AD"],
+    "MONOALLELIC, autosomal or pseudoautosomal, imprinted status unknown": ["AD"],
+    "MONOALLELIC, autosomal or pseudoautosomal, maternally imprinted (paternal allele expressed)": [
+        "AD"
+    ],
+    "MONOALLELIC, autosomal or pseudoautosomal, paternally imprinted (maternal allele expressed)": [
+        "AD"
+    ],
+    "BIALLELIC, autosomal or pseudoautosomal": ["AR"],
+    "BOTH monoallelic and biallelic, autosomal or pseudoautosomal": ["AD", "AR"],
+    "BOTH monoallelic and biallelic (but BIALLELIC mutations cause a more SEVERE disease form), autosomal or pseudoautosomal": [
+        "AD",
+        "AR",
+    ],
+    "X-LINKED: hemizygous mutation in males, biallelic mutations in females": ["XR"],
+    "X-LINKED: hemizygous mutation in males, monoallelic mutations in females may cause disease (may be less severe, later onset than males)": [
+        "XD"
+    ],
+    "MITOCHONDRIAL": ["MT"],
+    "Other": [],
+    "Other - please specifiy in evaluation comments": [],
 }
 
 PANEL_GENE_INFO_TRANSCRIPTS = [

scout/demo/cancer.load_config.yaml

@@ -44,9 +44,7 @@ delivery_report: scout/demo/delivery_report.html
 cnv_report: scout/demo/cancer_cnv_report.pdf
 coverage_qc_report: scout/demo/cancer_coverage_qc_report.html
 
-
-# meta data
-rank_model_version: '1.1'
+# metadata
 rank_score_threshold: -100
 analysis_date: 2018-10-12 14:00:46
 human_genome_build: '37'

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/load/panelapp.py

@@ -1,9 +1,9 @@
 import logging
 import math
 from datetime import datetime
-from typing import Dict, List, Set
+from typing import List, Set
 
-from click import Abort, progressbar
+from click import progressbar
 
 from scout.adapter import MongoAdapter
 from scout.constants.panels import PRESELECTED_PANELAPP_PANEL_TYPE_SLUGS
@@ -28,15 +28,11 @@ def load_panelapp_panel(
         LOG.info("Fetching all panel app panels")
         panel_ids: List[str] = panelapp.get_panel_ids(signed_off=False)
 
-    ensembl_id_to_hgnc_id_map: Dict[str, int] = adapter.ensembl_to_hgnc_id_mapping()
-    hgnc_symbol_to_ensembl_id_map: Dict[int, str] = adapter.hgnc_symbol_ensembl_id_mapping()
-
-    for _ in panel_ids:
+    for panel_id in panel_ids:
         panel_info: dict = panelapp.get_panel(panel_id)
         parsed_panel = parse_panelapp_panel(
+            hgnc_gene_ids=adapter.hgnc_ids(),
             panel_info=panel_info,
-            ensembl_id_to_hgnc_id_map=ensembl_id_to_hgnc_id_map,
-            hgnc_symbol_to_ensembl_id_map=hgnc_symbol_to_ensembl_id_map,
             institute=institute,
             confidence=confidence,
         )
@@ -54,8 +50,6 @@ def get_panelapp_genes(
     """Parse and collect genes from one or more panelApp panels."""
 
     genes = set()
-    ensembl_id_to_hgnc_id_map: Dict[str, int] = adapter.ensembl_to_hgnc_id_mapping()
-    hgnc_symbol_to_ensembl_id_map: Dict[int, str] = adapter.hgnc_symbol_ensembl_id_mapping()
 
     with progressbar(panel_ids, label="Parsing panels", length=len(panel_ids)) as panel_ids:
         for panel_id in panel_ids:
@@ -66,9 +60,8 @@ def get_panelapp_genes(
                 continue
 
             parsed_panel = parse_panelapp_panel(
+                hgnc_gene_ids=adapter.hgnc_ids(),
                 panel_info=panel_dict,
-                ensembl_id_to_hgnc_id_map=ensembl_id_to_hgnc_id_map,
-                hgnc_symbol_to_ensembl_id_map=hgnc_symbol_to_ensembl_id_map,
                 institute=institute,
                 confidence="green",
             )
@@ -86,6 +79,8 @@ def load_panelapp_green_panel(adapter: MongoAdapter, institute: str, force: bool
         """Translate panel type input from users to panel type slugs."""
         if not types_filter:
             return PRESELECTED_PANELAPP_PANEL_TYPE_SLUGS
+        if "all" in types_filter:
+            return available_types
         index_list = [int(typeint) - 1 for typeint in types_filter.replace(" ", "").split(",")]
         return [available_types[i] for i in index_list]
 
@@ -107,6 +102,7 @@ def load_panelapp_green_panel(adapter: MongoAdapter, institute: str, force: bool
     available_types: List[str] = panelapp.get_panel_types()
     for number, type in enumerate(available_types, 1):
         LOG.info(f"{number}: {type}")
+    LOG.info("all: all types above")
     preselected_options_idx: List[str] = [
         str(available_types.index(presel) + 1)
         for presel in PRESELECTED_PANELAPP_PANEL_TYPE_SLUGS

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:
@@ -436,6 +438,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/parse/case.py

@@ -34,6 +34,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

scout/parse/omim.py

@@ -311,7 +311,6 @@ def get_mim_genes(genemap_lines, mim2gene_lines):
         mim_number = entry["mim_number"]
         inheritance = entry["inheritance"]
         phenotype_info = entry["phenotypes"]
-        hgnc_symbol = entry["hgnc_symbol"]
         hgnc_symbols = entry["hgnc_symbols"]
         if mim_number in genes:
             genes[mim_number]["inheritance"] = inheritance
@@ -354,11 +353,11 @@ def get_mim_disease(genemap_lines: Iterable[str]) -> Dict[str, Any]:
     """
     diseases_found = {}
 
-    # Genemap is a file with one entry per gene.
-    # Each line hold a lot of information and in specific it
-    # has information about the phenotypes that a gene is associated with
-    # From this source we collect inheritane patterns and what hgnc symbols
-    # a disease is associated with
+    # Genemap2 is a file with one entry per gene.
+    # Each line hold a lot of information and in particular it
+    # has information about the phenotypes that a gene is associated with.
+    # From this source we collect inheritance patterns and what hgnc symbols
+    # a disease is associated with.
     for entry in parse_genemap2(genemap_lines):
         hgnc_symbol = entry["hgnc_symbol"]
         for disease in entry["phenotypes"]:

scout/parse/panelapp.py

@@ -1,7 +1,7 @@
 """Code to parse panel information"""
 
 import logging
-from typing import Dict, Optional
+from typing import Optional, Set
 
 from scout.constants import INCOMPLETE_PENETRANCE_MAP, MODELS_MAP, PANELAPP_CONFIDENCE_EXCLUDE
 from scout.utils.date import get_date
@@ -11,9 +11,8 @@ PANELAPP_PANELS_URL = "https://panelapp.genomicsengland.co.uk/panels/"
 
 
 def parse_panel_app_gene(
+    hgnc_gene_ids: Set[int],
     panelapp_gene: dict,
-    ensembl_gene_hgnc_id_map: Dict[str, int],
-    hgnc_symbol_ensembl_gene_map: Dict[str, str],
     confidence: str,
 ) -> dict:
     """Parse a panel app-formatted gene."""
@@ -23,55 +22,30 @@ def parse_panel_app_gene(
     if confidence_level in PANELAPP_CONFIDENCE_EXCLUDE[confidence]:
         return gene_info
 
-    hgnc_symbol = panelapp_gene["gene_data"]["gene_symbol"]
-    ensembl_ids = [
-        version["ensembl_id"]
-        for genome in panelapp_gene["gene_data"]["ensembl_genes"].values()
-        for version in genome.values()
-    ]
-
-    if not ensembl_ids:  # This gene is probably tagged as ensembl_ids_known_missing on PanelApp
-        if hgnc_symbol in hgnc_symbol_ensembl_gene_map:
-            LOG.warning(
-                f"PanelApp gene {hgnc_symbol} does not contain Ensembl IDs. Using Ensembl IDs from internal gene collection instead."
-            )
-            ensembl_ids = [hgnc_symbol_ensembl_gene_map[hgnc_symbol]]
-        else:
-            LOG.warning(
-                f"PanelApp gene {hgnc_symbol} does not contain Ensembl IDs and gene symbol does not correspond to a gene in scout."
-            )
-
-    hgnc_ids = set(
-        ensembl_gene_hgnc_id_map.get(ensembl_id)
-        for ensembl_id in ensembl_ids
-        if ensembl_gene_hgnc_id_map.get(ensembl_id)
-    )
-    if not hgnc_ids:
-        LOG.warning("Gene %s does not exist in database. Skipping gene...", hgnc_symbol)
+    gene_symbol = panelapp_gene["gene_data"]["gene_symbol"]
+    hgnc_id = int(panelapp_gene["gene_data"]["hgnc_id"].split(":")[1])
+    if hgnc_id not in hgnc_gene_ids:
+        LOG.warning("Gene %s does not exist in database. Skipping gene...", gene_symbol)
         return gene_info
 
-    if len(hgnc_ids) > 1:
-        LOG.warning("Gene %s has unclear identifier. Choose random id", hgnc_symbol)
+    gene_info["hgnc_id"] = hgnc_id
+    gene_info["hgnc_symbol"] = gene_symbol
 
-    gene_info["hgnc_symbol"] = hgnc_symbol
-    for hgnc_id in hgnc_ids:
-        gene_info["hgnc_id"] = hgnc_id
+    if panelapp_gene["penetrance"] in ["Complete", "Incomplete"]:
+        gene_info["reduced_penetrance"] = INCOMPLETE_PENETRANCE_MAP.get(panelapp_gene["penetrance"])
 
-    gene_info["reduced_penetrance"] = INCOMPLETE_PENETRANCE_MAP.get(panelapp_gene["penetrance"])
+    mode_of_inheritance = panelapp_gene.get("mode_of_inheritance")
+    if mode_of_inheritance not in MODELS_MAP:
+        LOG.warning(f"Mode of inheritance '{mode_of_inheritance}' not found in MODELS_MAP.")
 
-    inheritance_models = []
-    for model in MODELS_MAP.get(panelapp_gene["mode_of_inheritance"], []):
-        inheritance_models.append(model)
-
-    gene_info["inheritance_models"] = inheritance_models
+    gene_info["inheritance_models"] = MODELS_MAP.get(mode_of_inheritance, [])
 
     return gene_info
 
 
 def parse_panelapp_panel(
+    hgnc_gene_ids: Set[int],
     panel_info: dict,
-    ensembl_id_to_hgnc_id_map: Dict[str, int],
-    hgnc_symbol_to_ensembl_id_map: Dict[str, str],
     institute: Optional[str] = "cust000",
     confidence: Optional[str] = "green",
 ) -> dict:
@@ -101,7 +75,7 @@ def parse_panelapp_panel(
     nr_genes = 0
     for nr_genes, gene in enumerate(panel_info["genes"], 1):
         gene_info = parse_panel_app_gene(
-            gene, ensembl_id_to_hgnc_id_map, hgnc_symbol_to_ensembl_id_map, confidence
+            hgnc_gene_ids=hgnc_gene_ids, panelapp_gene=gene, confidence=confidence
         )
         if not gene_info:
             nr_excluded += 1

scout/parse/variant/compound.py

@@ -1,43 +1,42 @@
 import logging
+from typing import List
 
 from scout.utils.md5 import generate_md5_key
 
 LOG = logging.getLogger(__name__)
 
 
-def parse_compounds(compound_info, case_id, variant_type):
-    """Get a list with compounds objects for this variant.
+def parse_compounds(compound_info: str, case_id: str, variant_type: str) -> List[dict]:
+    """Get a list with compounds objects(dicts) for this variant.
 
-    Arguments:
-        compound_info(str): A Variant dictionary
-        case_id (str): unique family id
-        variant_type(str): 'research' or 'clinical'
+    Scout IDs do not have "chr" prefixed chromosome names, hence we lstrip that from
+    any compound names.
+
+    We need the case id to construct the correct id, as well as the variant type (clinical or research).
 
-    Returns:
-        compounds(list(dict)): A list of compounds
     """
-    # We need the case to construct the correct id
+
     compounds = []
     if compound_info:
         for family_info in compound_info.split(","):
-            splitted_entry = family_info.split(":")
+            split_entry = family_info.split(":")
             # This is the family id
-            if splitted_entry[0] == case_id:
-                for compound in splitted_entry[1].split("|"):
-                    splitted_compound = compound.split(">")
-                    compound_obj = {}
-                    compound_name = splitted_compound[0]
-                    compound_obj["variant"] = generate_md5_key(
-                        compound_name.split("_") + [variant_type, case_id]
-                    )
+            if split_entry[0] == case_id:
+                for compound in split_entry[1].split("|"):
+                    split_compound = compound.split(">")
+                    compound_name = split_compound[0].lstrip("chr")
+                    compound_obj = {
+                        "display_name": compound_name,
+                        "variant": generate_md5_key(
+                            compound_name.split("_") + [variant_type, case_id]
+                        ),
+                    }
 
                     try:
-                        compound_score = float(splitted_compound[1])
+                        compound_score = float(split_compound[1])
                     except (TypeError, IndexError):
                         compound_score = 0.0
-
                     compound_obj["score"] = compound_score
-                    compound_obj["display_name"] = compound_name
 
                     compounds.append(compound_obj)
 

scout/server/app.py

@@ -13,6 +13,7 @@ from flask_login import current_user
 from markdown import markdown as python_markdown
 from markupsafe import Markup
 
+from scout.constants import SPIDEX_HUMAN
 from scout.log import init_log
 
 from . import extensions
@@ -199,6 +200,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.