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

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,68 +469,105 @@ 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
 
-    def sv_coordinate_query(self, query):
-        """Adds genomic coordinated-related filters to the query object
-            This method is called to buid coordinate query for sv variants
+    def get_position_query(self, chrom: str, start: int, end: int) -> dict:
+        """Helper function that returns a dictionary containing start and stop coordinates.
 
-        Args:
-            query(dict): a dictionary of query filters specified by the users
-            mongo_query(dict): the query that is going to be submitted to the database
+        The position query consists of 3 parts, each of them elements of the $or
+        First part applies to searches when chromosome and end_chrom are the same.
+        Here are the possible overlapping search scenarios:
+        # Case 1
+        # filter                 xxxxxxxxx
+        # Variant           xxxxxxxx
 
-        Returns:
-            coordinate_query(dict): returned object contains coordinate filters for sv variant
+        # Case 2
+        # filter                 xxxxxxxxx
+        # Variant                    xxxxxxxx
+
+        # Case 3
+        # filter                 xxxxxxxxx
+        # Variant                   xx
 
+        # Case 4
+        # filter                 xxxxxxxxx
+        # Variant             xxxxxxxxxxxxxx
+
+        Second and third elements of the $or cover queries for variants where chromosome != end_chrom.
+        In this situation there are the following scenarios:
+        - Case chromosome != end_chrom, position matching 'chromosome'
+        - Case chromosome != end_chrom, position matching 'end_chrom'
         """
-        coordinate_query = None
-        chromosome_query = {"$or": [{"chromosome": query["chrom"]}, {"end_chrom": query["chrom"]}]}
-        if query.get("start") and query.get("end"):
-            # Query for overlapping intervals. Taking into account these cases:
-            # 1
-            # filter                 xxxxxxxxx
-            # Variant           xxxxxxxx
-
-            # 2
-            # filter                 xxxxxxxxx
-            # Variant                    xxxxxxxx
-
-            # 3
-            # filter                 xxxxxxxxx
-            # Variant                   xx
-
-            # 4
-            # filter                 xxxxxxxxx
-            # Variant             xxxxxxxxxxxxxx
-            position_query = {
-                "$or": [
-                    {"end": {"$gte": int(query["start"]), "$lte": int(query["end"])}},  # 1
-                    {
-                        "position": {
-                            "$lte": int(query["end"]),
-                            "$gte": int(query["start"]),
-                        }
-                    },  # 2
-                    {
-                        "$and": [
-                            {"position": {"$gte": int(query["start"])}},
-                            {"end": {"$lte": int(query["end"])}},
-                        ]
-                    },  # 3
-                    {
-                        "$and": [
-                            {"position": {"$lte": int(query["start"])}},
-                            {"end": {"$gte": int(query["end"])}},
-                        ]
-                    },  # 4
-                ]
+
+        return {
+            "$or": [
+                # Case chromosome == end_chrom
+                {
+                    "$and": [
+                        {"chromosome": chrom},
+                        {"end_chrom": chrom},
+                        {
+                            "$or": [
+                                # Overlapping cases 1-4 (chromosome == end_chrom)
+                                {"end": {"$gte": start, "$lte": end}},  # Case 1
+                                {"position": {"$gte": start, "$lte": end}},  # Case 2
+                                {
+                                    "$and": [
+                                        {"position": {"$lte": start}},
+                                        {"end": {"$gte": end}},
+                                    ]
+                                },  # Case 3
+                                {
+                                    "$and": [
+                                        {"position": {"$gte": start}},
+                                        {"end": {"$lte": end}},
+                                    ]
+                                },  # Case 4
+                            ]
+                        },
+                    ]
+                },
+                # Case chromosome != end_chrom, position matching 'chromosome'
+                {
+                    "$and": [
+                        {"chromosome": chrom},
+                        {"end_chrom": {"$ne": chrom}},
+                        {"position": {"$gte": start}},
+                        {"position": {"$lte": end}},
+                    ]
+                },
+                # Case chromosome != end_chrom, position matching 'end_chrom'
+                {
+                    "$and": [
+                        {"chromosome": {"$ne": chrom}},
+                        {"end_chrom": chrom},
+                        {"end": {"$gte": start}},
+                        {"end": {"$lte": end}},
+                    ]
+                },
+            ]
+        }
+
+    def sv_coordinate_query(self, query: dict) -> dict:
+        """Adds genomic coordinated-related filters to the query object
+        This method is called to build coordinate query for sv variants
+        """
+        if (
+            query.get("start") is not None and query.get("end") is not None
+        ):  # query contains full coordinates
+            chrom = query["chrom"]
+            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 = {
+                "$or": [{"chromosome": query["chrom"]}, {"end_chrom": query["chrom"]}]
             }
-            coordinate_query = {"$and": [chromosome_query, position_query]}
-        else:
-            coordinate_query = chromosome_query
         return coordinate_query
 
     def gene_filter(self, query, build="37"):

scout/adapter/mongo/variant.py

@@ -311,14 +311,14 @@ class VariantHandler(VariantLoader):
             "category": variant_obj["category"],  # sv
             "variant_type": variant_obj["variant_type"],  # clinical or research
             "sub_category": variant_obj["sub_category"],  # example -> "del"
-            "$and": coordinate_query["$and"],  # query for overlapping SV variants
+            "$or": coordinate_query["$or"],  # query for overlapping SV variants
         }
-
         overlapping_svs = list(
             self.variant_collection.find(
                 query,
             )
         )
+
         if not overlapping_svs:
             return None
         if len(overlapping_svs) == 1:
@@ -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/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/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/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/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/blueprints/cases/controllers.py

@@ -62,6 +62,8 @@ from scout.server.utils import (
     case_has_rna_tracks,
     institute_and_case,
 )
+from scout.utils.acmg import get_acmg_temperature
+from scout.utils.ccv import get_ccv_temperature
 
 LOG = logging.getLogger(__name__)
 
@@ -611,6 +613,46 @@ def check_outdated_gene_panel(panel_obj, latest_panel):
     return extra_genes, missing_genes
 
 
+def add_bayesian_acmg_classification(variant_obj: dict):
+    """Append info to display the ACMG VUS Bayesian score / temperature.
+    Criteria have a term and a modifier field on the db document
+    that are joined together in a string to conform to a regular
+    ACMG term format. A set of such terms are passed on for evaluation
+    to the same function as the ACMG classification form uses.
+    """
+    variant_acmg_classifications = list(
+        store.get_evaluations_case_specific(document_id=variant_obj["_id"])
+    )
+    if variant_acmg_classifications:
+        terms = set()
+        for criterium in variant_acmg_classifications[0].get("criteria", []):
+            term = criterium.get("term")
+            if criterium.get("modifier"):
+                term += f"_{criterium.get('modifier')}"
+            terms.add(term)
+        variant_obj["bayesian_acmg"] = get_acmg_temperature(terms)
+
+
+def add_bayesian_ccv_classification(variant_obj: dict):
+    """Append info to display the CCV VUS Bayesian score / temperature.
+    Criteria have a term and a modifier field on the db document
+    that are joined together in a string to conform to a regular
+    CCV term format. A set of such terms are passed on for evaluation
+    to the same function as the CCV classification form uses.
+    """
+    variant_ccv_classifications = list(
+        store.get_ccv_evaluations_case_specific(document_id=variant_obj["_id"])
+    )
+    if variant_ccv_classifications:
+        terms = set()
+        for criterium in variant_ccv_classifications[0].get("ccv_criteria", []):
+            term = criterium.get("term")
+            if criterium.get("modifier"):
+                term += f"_{criterium.get('modifier')}"
+            terms.add(term)
+        variant_obj["bayesian_ccv"] = get_ccv_temperature(terms)
+
+
 def case_report_variants(store: MongoAdapter, case_obj: dict, institute_obj: dict, data: dict):
     """Gather evaluated variants info to include in case report."""
 
@@ -624,6 +666,8 @@ def case_report_variants(store: MongoAdapter, case_obj: dict, institute_obj: dic
                 continue
             if case_key == "partial_causatives":
                 var_obj["phenotypes"] = case_obj["partial_causatives"][var_id]
+            add_bayesian_acmg_classification(var_obj)
+            add_bayesian_ccv_classification(var_obj)
             evaluated_variants_by_type[eval_category].append(
                 _get_decorated_var(var_obj=var_obj, institute_obj=institute_obj, case_obj=case_obj)
             )
@@ -663,6 +707,10 @@ def _append_evaluated_variant_by_type(
     """
     for eval_category, variant_key in CASE_REPORT_VARIANT_TYPES.items():
         if variant_key in var_obj and var_obj[variant_key] is not None:
+
+            add_bayesian_acmg_classification(var_obj)
+            add_bayesian_ccv_classification(var_obj)
+
             evaluated_variants_by_type[eval_category].append(
                 _get_decorated_var(var_obj=var_obj, institute_obj=institute_obj, case_obj=case_obj)
             )