scout-browser 4.102.0__py3-none-any.whl → 4.103.1__py3-none-any.whl

scout/constants/__init__.py

@@ -36,6 +36,7 @@ from .clinvar import (
     CONDITION_PREFIX,
     GERMLINE_CLASSIF_TERMS,
     MULTIPLE_CONDITION_EXPLANATION,
+    ONCOGENIC_CLASSIF_TERMS,
 )
 from .clnsig import CLINSIG_MAP, ONC_CLNSIG, REV_CLINSIG_MAP, TRUSTED_REVSTAT_LEVEL
 from .disease_parsing import (
@@ -100,8 +101,10 @@ from .variant_tags import (
     MANUAL_RANK_OPTIONS,
     MOSAICISM_OPTIONS,
     OUTLIER_TYPES,
+    REVEL_SCORE_LABEL_COLOR_MAP,
     SPIDEX_HUMAN,
     SPIDEX_LEVELS,
+    SPLICEAI_SCORE_LABEL_COLOR_MAP,
     SV_TYPES,
     VARIANT_CALL,
     VARIANT_FILTERS,

scout/constants/clinvar.py

@@ -1,8 +1,12 @@
+from scout.constants.clnsig import ONC_CLNSIG
+
 CLINVAR_API_URL_DEFAULT = "https://submit.ncbi.nlm.nih.gov/api/v1/submissions/"
 PRECLINVAR_URL = "https://preclinvar.scilifelab.se"
 
 ASSERTION_METHOD = "ACMG Guidelines, 2015"
 ASSERTION_METHOD_CIT = "PMID:25741868"
+ASSERTION_ONC_ONC_DB = "PubMed"
+ASSERTION_CRITERIA_ONC_ID = "36063163"
 NOT_PROVIDED = "not provided"
 
 # Header used to create the Variant .CSV file for the manual ClinVar submission
@@ -95,6 +99,8 @@ GERMLINE_CLASSIF_TERMS = [
     NOT_PROVIDED,
 ]
 
+ONCOGENIC_CLASSIF_TERMS = ONC_CLNSIG
+
 REVSTAT_TERMS = {
     "conflicting_interpretations",
     "multiple_submitters",
@@ -187,6 +193,10 @@ CONDITION_PREFIX = {
     "Orphanet": "ORPHA",
 }
 
+CONDITION_DBS_API = ["HP", "MedGen", "MeSH", "MONDO", "OMIM", "Orphanet"]
+
 CLINVAR_ASSERTION_METHOD_CIT_DB_OPTIONS = {"DOI", "pmc", "PMID"}
+CITATION_DBS_API = ["PubMed", "BookShelf", "DOI", "pmc"]
 
 MULTIPLE_CONDITION_EXPLANATION = ["Novel disease", "Uncertain", "Co-occurring"]
+PRESENCE_IN_NORMAL_TISSUE = ["present", "absent", "not tested"]

scout/constants/variant_tags.py

@@ -19,6 +19,22 @@ CONSERVATION = {
     "phylop": {"conserved_min": 2.5, "conserved_max": 100},
 }
 
+REVEL_SCORE_LABEL_COLOR_MAP = {
+    (0.932, 1.000): {"label": "Strong pathogenic", "color": "danger"},
+    (0.773, 0.932): {"label": "Moderate pathogenic", "color": "red"},
+    (0.644, 0.773): {"label": "Supporting pathogenic", "color": "orange"},
+    (0.290, 0.644): {"label": "Uncertain significance", "color": "secondary"},
+    (0.183, 0.290): {"label": "Supporting benign", "color": "info"},
+    (0.016, 0.183): {"label": "Moderate benign", "color": "info"},
+    (0.0, 0.016): {"label": "Strong to very strong benign", "color": "success"},
+}
+
+SPLICEAI_SCORE_LABEL_COLOR_MAP = {
+    (0.20, 1.00): {"label": "Predicted impact on splicing", "color": "warning"},
+    (0.10, 0.20): {"label": "Not informative", "color": "secondary"},
+    (0.00, 0.10): {"label": "No impact on splicing", "color": "success"},
+}
+
 FEATURE_TYPES = (
     "exonic",
     "splicing",
@@ -535,6 +551,7 @@ CALLERS = {
         {"id": "deepvariant", "name": "DeepVariant"},
         _FREEBAYES,
         _GATK,
+        {"id": "mutect2", "name": "MuTect2"},
         {"id": "samtools", "name": "SAMtools"},
     ],
     "cancer": [
@@ -562,6 +579,7 @@ CALLERS = {
         {"id": "cnvpytor", "name": "CNVpytor"},
         {"id": "delly", "name": "Delly"},
         _GATK,
+        {"id": "gcnvcaller", "name": "GATK GermlineCNV"},
         {"id": "hificnv", "name": "HiFiCNV"},
         _MANTA,
         {"id": "severus", "name": "Severus"},

scout/demo/__init__.py

@@ -25,6 +25,7 @@ gene_fusion_report_path = str(files(BASE_PATH).joinpath("draw-fusions-example.pd
 clinical_snv_path = str(files(BASE_PATH).joinpath("643594.clinical.vcf.gz"))
 clinical_sv_path = str(files(BASE_PATH).joinpath("643594.clinical.SV.vcf.gz"))
 clinical_str_path = str(files(BASE_PATH).joinpath("643594.clinical.str.stranger.vcf.gz"))
+str_trgt_path = str(files(BASE_PATH).joinpath("NIST.trgt.stranger.vcf.gz"))
 clinical_fusion_path = str(files(BASE_PATH).joinpath("fusion_data.vcf"))
 customannotation_snv_path = str(files(BASE_PATH).joinpath("customannotations_one.vcf.gz"))
 vep_97_annotated_path = str(

scout/models/clinvar.py

@@ -1,6 +1,12 @@
 from datetime import date, datetime
+from enum import Enum
+from typing import List, Literal, Optional
 
 from bson.objectid import ObjectId
+from pydantic import BaseModel
+
+from scout.constants import CHROMOSOMES
+from scout.constants.clinvar import CITATION_DBS_API, ONCOGENIC_CLASSIF_TERMS
 
 """Model of the document that gets saved/updated in the clinvar_submission collection
  for each institute that has cases with ClinVar submission objects"""
@@ -76,3 +82,83 @@ clinvar_casedata = {
     "method_purpose": str,  # default: "discovery"
     "reported_at": date,
 }
+
+### Models used for oncogenocity submissions via API
+
+
+CitationDB = Enum("CitationDB", {db.upper(): db for db in CITATION_DBS_API})
+OncogenicityClassificationDescription = Enum(
+    "OncogenicityClassificationDescription",
+    {term.upper().replace(" ", "_"): term for term in ONCOGENIC_CLASSIF_TERMS},
+)
+
+
+class Citation(BaseModel):
+    db: CitationDB
+    id: str
+
+
+class OncogenicityClassification(BaseModel):
+    oncogenicityClassificationDescription: OncogenicityClassificationDescription
+    dateLastEvaluated: str
+    comment: Optional[str] = None
+    citation: Optional[List[Citation]] = None
+
+
+class ObservedIn(BaseModel):
+    alleleOrigin: str
+    affectedStatus: str
+    collectionMethod: str
+    numberOfIndividuals: int
+    presenceOfSomaticVariantInNormalTissue: str
+    somaticVariantAlleleFraction: Optional[float] = None
+
+
+class Gene(BaseModel):
+    symbol: str
+
+
+Chromosome = Enum(
+    "Chromosome", {c: c for c in CHROMOSOMES}
+)  # ClinVar API accepts only 'MT' chromosome
+
+
+class Variant(BaseModel):
+    """It's defined by either coordinates or hgvs."""
+
+    alternateAllele: Optional[str] = None
+    assembly: Optional[Literal["GRCh37", "GRCh38"]] = None
+    chromosome: Optional[Chromosome] = None
+    gene: Optional[List[Gene]] = None
+    hgvs: Optional[str] = None
+    start: Optional[int] = None
+    stop: Optional[int] = None
+
+
+class VariantSet(BaseModel):
+    variant: List[Variant]
+
+
+class Condition(BaseModel):
+    db: Optional[str] = None
+    id: Optional[str] = None
+    name: Optional[str] = None
+
+
+class ConditionSet(BaseModel):
+    condition: List[Condition]
+
+
+class OncogenicitySubmissionItem(BaseModel):
+    # Field necessary for the API submissions:
+    recordStatus: str
+    oncogenicityClassification: OncogenicityClassification
+    observedIn: List[ObservedIn]
+    variantSet: VariantSet
+    conditionSet: ConditionSet
+
+    # Fields necessary to map the variant to a variant in Scout:
+    institute_id: str
+    case_id: str
+    case_name: str
+    variant_id: str

scout/parse/variant/coordinates.py

@@ -1,6 +1,6 @@
 """Code to parse variant coordinates"""
 
-from scout.constants import BND_ALT_PATTERN, CHR_PATTERN, CYTOBANDS_37, CYTOBANDS_38
+from scout.constants import BND_ALT_PATTERN, CHR_PATTERN, CYTOBANDS_37, CYTOBANDS_38, SV_TYPES
 
 
 def get_cytoband_coordinates(chrom, pos, build):
@@ -144,6 +144,10 @@ def parse_coordinates(variant, category, build="37"):
         svtype = variant.INFO.get("SVTYPE")
         if svtype:
             svtype = svtype.lower()
+        else:
+            alt_type = alt.lstrip("<").rstrip(">").lower()
+            if alt_type in SV_TYPES:
+                svtype = alt_type
         sub_category = svtype
         if sub_category == "bnd":
             end_chrom = get_end_chrom(alt, chrom)

scout/parse/variant/gene.py

@@ -48,10 +48,6 @@ def parse_genes(transcripts):
     # List with all genes and their transcripts
     genes = []
 
-    hgvs_identifier = None
-    canonical_transcript = None
-    exon = None
-
     # Loop over all genes
     for gene_id in genes_to_transcripts:
         # Get the transcripts for a gene
@@ -78,8 +74,7 @@ def parse_genes(transcripts):
             hgnc_symbol = transcript["hgnc_symbol"]
             if not hgvs_identifier:
                 hgvs_identifier = transcript.get("coding_sequence_name")
-            if not canonical_transcript:
-                canonical_transcript = transcript["transcript_id"]
+
             if not exon:
                 exon = transcript["exon"]
 
@@ -102,10 +97,11 @@ def parse_genes(transcripts):
                 most_severe_spliceai_position = transcript["spliceai_delta_position"]
                 spliceai_prediction = transcript["spliceai_prediction"]
 
-            if transcript["is_canonical"] and transcript.get("coding_sequence_name"):
-                hgvs_identifier = transcript.get("coding_sequence_name")
+            if transcript["is_canonical"]:
                 canonical_transcript = transcript["transcript_id"]
-                exon = transcript["exon"]
+                if transcript.get("coding_sequence_name"):
+                    hgvs_identifier = transcript.get("coding_sequence_name")
+                    exon = transcript["exon"]
 
         gene = {
             "transcripts": gene_transcripts,

scout/parse/variant/genotype.py

@@ -18,6 +18,7 @@ Uses 'DV' to describe number of paired ends that supports the event and
 
 """
 
+import ast
 import logging
 from typing import Dict, List, Optional, Tuple, Union
 
@@ -101,7 +102,7 @@ def parse_genotype(variant, ind, pos):
     (_, mc_alt) = _parse_format_entry_trgt_mc(variant, pos)
     gt_call["alt_mc"] = mc_alt
 
-    (sd_ref, sd_alt) = _parse_format_entry(variant, pos, "SD", float)
+    (sd_ref, sd_alt) = _parse_format_entry(variant, pos, "SD", int)
     (ap_ref, ap_alt) = _parse_format_entry(variant, pos, "AP", float)
     (am_ref, am_alt) = _parse_format_entry(variant, pos, "AM", float)
 
@@ -122,6 +123,7 @@ def parse_genotype(variant, ind, pos):
         spanning_alt,
         flanking_alt,
         inrepeat_alt,
+        sd_alt,
         clip5_alt,
         clip3_alt,
     )
@@ -135,8 +137,10 @@ def parse_genotype(variant, ind, pos):
         spanning_ref,
         flanking_ref,
         inrepeat_ref,
+        sd_ref,
         spanning_mei_ref,
     )
+
     gt_call["ref_depth"] = ref_depth
     gt_call["read_depth"] = get_read_depth(variant, pos, alt_depth, ref_depth)
     gt_call["alt_frequency"] = get_alt_frequency(variant, pos)
@@ -202,7 +206,7 @@ def get_ffpm_info(variant: cyvcf2.Variant, pos: Dict[str, int]) -> Optional[int]
             pass
 
 
-def get_paired_ends(variant, pos):
+def get_paired_ends(variant: cyvcf2.Variant, pos: int) -> tuple:
     """Get paired ends"""
     # SV specific
     paired_end_alt = None
@@ -224,9 +228,10 @@ def get_paired_ends(variant, pos):
         values = variant.format("PR")[pos]
         try:
             alt_value = int(values[1])
-            ref_value = int(values[0])
             if alt_value >= 0:
                 paired_end_alt = alt_value
+
+            ref_value = int(values[0])
             if ref_value >= 0:
                 paired_end_ref = ref_value
         except ValueError as _ignore_error:
@@ -317,32 +322,30 @@ def get_read_depth(variant, pos, alt_depth, ref_depth):
 
 
 def get_ref_depth(
-    variant,
-    pos,
-    paired_end_ref,
-    split_read_ref,
-    spanning_ref,
-    flanking_ref,
-    inrepeat_ref,
-    spanning_mei_ref,
-):
+    variant: cyvcf2.Variant,
+    pos: int,
+    paired_end_ref: int,
+    split_read_ref: int,
+    spanning_ref: int,
+    flanking_ref: int,
+    inrepeat_ref: int,
+    sd_ref: int,
+    spanning_mei_ref: int,
+) -> int:
     """Get reference read depth"""
     ref_depth = int(variant.gt_ref_depths[pos])
     if ref_depth != -1:
         return ref_depth
 
     REF_ITEMS_LIST: List[tuple] = [
+        (sd_ref,),
         (paired_end_ref, split_read_ref),
         (spanning_ref, flanking_ref, inrepeat_ref),
     ]
 
-    for list in REF_ITEMS_LIST:
-        if all(item is None for item in list):
-            continue
-        ref_depth = 0
-        for item in list:
-            if item:
-                ref_depth += item
+    for items in REF_ITEMS_LIST:
+        if any(item is not None for item in items):
+            ref_depth = sum(item for item in items if item)
 
     if spanning_mei_ref:
         ref_depth += spanning_mei_ref
@@ -350,16 +353,17 @@ def get_ref_depth(
 
 
 def get_alt_depth(
-    variant,
-    pos,
-    paired_end_alt,
-    split_read_alt,
-    spanning_alt,
-    flanking_alt,
-    inrepeat_alt,
-    clip5_alt,
-    clip3_alt,
-):
+    variant: cyvcf2.Variant,
+    pos: int,
+    paired_end_alt: int,
+    split_read_alt: int,
+    spanning_alt: int,
+    flanking_alt: int,
+    inrepeat_alt: int,
+    sd_alt: int,
+    clip5_alt: int,
+    clip3_alt: int,
+) -> int:
     """Get alternative read depth"""
     alt_depth = int(variant.gt_alt_depths[pos])
     if alt_depth != -1:
@@ -369,19 +373,15 @@ def get_alt_depth(
         alt_depth = int(variant.format("VD")[pos][0])
 
     ALT_ITEMS_LIST: List[tuple] = [
+        (sd_alt,),
         (paired_end_alt, split_read_alt),
         (clip5_alt, clip3_alt),
         (spanning_alt, flanking_alt, inrepeat_alt),
     ]
 
-    for list in ALT_ITEMS_LIST:
-        if all(item is None for item in list):
-            continue
-        alt_depth = 0
-        for item in list:
-            if item:
-                alt_depth += item
-
+    for items in ALT_ITEMS_LIST:
+        if any(item is not None for item in items):
+            alt_depth = sum(item for item in items if item)
     return alt_depth
 
 
@@ -430,7 +430,13 @@ def _parse_format_entry(
     alt = None
     if format_entry_name in variant.FORMAT:
         try:
-            values = split_values(variant.format(format_entry_name)[pos])
+            requested_format_entry = variant.format(format_entry_name)[pos]
+
+            values = (
+                split_values(requested_format_entry)
+                if type(requested_format_entry) is str
+                else requested_format_entry
+            )
 
             ref_value = None
             alt_value = None
@@ -440,15 +446,31 @@ def _parse_format_entry(
                 alt_value = (number_format)(values[1])
             if len(values) == 1:
                 alt_value = (number_format)(values[0])
-            if ref_value >= 0:
+            if ref_value and ref_value >= 0:
                 ref = ref_value
-            if alt_value >= 0:
+            if alt_value and alt_value >= 0:
                 alt = alt_value
         except (ValueError, TypeError) as _ignore_error:
             pass
     return (ref, alt)
 
 
+def _get_pathologic_struc(variant: cyvcf2.Variant) -> Optional[list]:
+    """Check for a PathologicStruc on the variant. If not present, return None.
+    If present, and in string format, convert to a list of ints.
+    If it is already parsed to a list by a later improvement in the parser,
+    simply return it.
+    """
+
+    pathologic_struc_entry = variant.INFO.get("PathologicStruc", None)
+    if not pathologic_struc_entry:
+        return pathologic_struc_entry
+    if type(pathologic_struc_entry) is str:
+        return ast.literal_eval(pathologic_struc_entry)
+    if type(pathologic_struc_entry) is list:
+        return pathologic_struc_entry
+
+
 def _parse_format_entry_trgt_mc(variant: cyvcf2.Variant, pos: int):
     """Parse genotype entry for TRGT FORMAT MC
 
@@ -477,14 +499,16 @@ def _parse_format_entry_trgt_mc(variant: cyvcf2.Variant, pos: int):
             if allele == 0:
                 ref_idx = idx
 
-    pathologic_struc = variant.INFO.get("PathologicStruc", None)
-    pathologic_counts = 0
+    pathologic_struc = _get_pathologic_struc(variant)
+
     for idx, allele in enumerate(mc.split(",")):
+
         mcs = allele.split("_")
 
         if len(mcs) > 1:
             pathologic_mcs = pathologic_struc or range(len(mcs))
 
+            pathologic_counts = 0
             for index, count in enumerate(mcs):
                 if index in pathologic_mcs:
                     pathologic_counts += int(count)

scout/parse/variant/variant.py

@@ -82,6 +82,8 @@ def parse_variant(
             variant_type=variant_type,
         ),
         "rank_score": parse_rank_score(variant.INFO.get("RankScore", ""), genmod_key) or 0,
+        "norm_rank_score": parse_rank_score(variant.INFO.get("RankScoreNormalized", ""), genmod_key)
+        or 0,
         "genetic_models": parse_genetic_models(variant.INFO.get("GeneticModels"), genmod_key),
         "str_swegen_mean": call_safe(float, variant.INFO.get("SweGenMean")),
         "str_swegen_std": call_safe(float, variant.INFO.get("SweGenStd")),

scout/server/app.py

@@ -4,7 +4,7 @@ import logging
 import os
 import re
 from datetime import timedelta
-from typing import Dict, Union
+from typing import Dict, List, Optional, Union
 from urllib.parse import parse_qsl, unquote, urlsplit
 
 from flask import Flask, redirect, request, url_for
@@ -14,7 +14,11 @@ from markdown import markdown as python_markdown
 from markupsafe import Markup
 
 from scout import __version__
-from scout.constants import SPIDEX_HUMAN
+from scout.constants import (
+    REVEL_SCORE_LABEL_COLOR_MAP,
+    SPIDEX_HUMAN,
+    SPLICEAI_SCORE_LABEL_COLOR_MAP,
+)
 from scout.log import init_log
 
 from . import extensions
@@ -207,6 +211,9 @@ def register_blueprints(app):
 
 
 def register_filters(app):
+    """Creates methods that can be invoked from jinja2 or views/controllers, given that they are included app.custom_filters."""
+    app.custom_filters = type("CustomFilters", (), {})()  # Create an empty object as namespace
+
     @app.template_filter()
     def human_longint(value: Union[int, str]) -> str:
         """Convert a long integers int or string representation into a human easily readable number."""
@@ -226,6 +233,27 @@ def register_filters(app):
             return "medium"
         return "high"
 
+    @app.template_filter()
+    def get_label_or_color_by_score(
+        score: float,
+        map: str,
+        map_key: str,
+    ) -> str:
+        """Return a label or color for a given score based on predefined score ranges from the provided items_map."""
+        SCORE_ITEM_MAPS = {
+            "revel": REVEL_SCORE_LABEL_COLOR_MAP,
+            "spliceai": SPLICEAI_SCORE_LABEL_COLOR_MAP,
+        }
+        for (low, high), info in SCORE_ITEM_MAPS[map].items():
+            if low <= score <= high:
+                return info[map_key]
+
+    @app.template_filter()
+    def l2fc_2_fc(l2fc: float) -> float:
+        """Converts Log2 fold change to fold change."""
+        fc = 2 ** abs(l2fc)
+        return fc if l2fc >= 0 else -1 / fc
+
     @app.template_filter()
     def human_decimal(number, ndigits=4):
         """Return a standard representation of a decimal number.
@@ -281,6 +309,33 @@ def register_filters(app):
             return "COSM" + str(cosmicId)
         return cosmicId
 
+    @app.template_filter()
+    def format_variant_canonical_transcripts(variant: dict) -> List[str]:
+        """Formats canonical transcripts for all genes in a variant."""
+
+        lines = set()
+        genes = variant.get("genes") or []
+
+        for gene in genes:
+            transcripts = gene.get("transcripts") or []
+            for tx in transcripts:
+                if not tx.get("is_canonical"):
+                    continue
+                canonical_tx = tx.get("transcript_id")
+                protein = tx.get("protein_sequence_name")
+            line_components = [f"{canonical_tx} ({gene.get('hgnc_symbol', '')})"]
+            hgvs = gene.get("hgvs_identifier")
+            if hgvs:
+                line_components.append(hgvs)
+            if protein:
+                line_components.append(protein)
+
+            lines.add(" ".join(line_components))
+
+        return list(lines)
+
+    app.custom_filters.format_variant_canonical_transcripts = format_variant_canonical_transcripts
+
     @app.template_filter()
     def upper_na(string):
         """
@@ -306,6 +361,20 @@ def register_filters(app):
         """Returns a list after removing any None values from it."""
         return [item for item in in_list if item is not None]
 
+    @app.template_filter()
+    def spliceai_max(values) -> Optional[float]:
+        """Returns a list of SpliceAI values, extracting floats only from values like 'score:0.23'."""
+        float_values = []
+        for value in values:
+            if isinstance(value, str):
+                if ":" in value:  # Variant hits multiple genes
+                    value = value.split(":")[1].strip()
+            if value in [None, "-", "None"]:
+                continue
+            float_values.append(float(value))
+        if float_values:
+            return max(float_values)
+
 
 def register_tests(app):
     @app.template_test("existing")

scout/server/blueprints/alignviewers/templates/alignviewers/igv_viewer.html

@@ -119,6 +119,8 @@
                         indexURL: "{{ url_for('alignviewers.remote_static', file=track.indexURL) }}",
                         sourceType: "file",
                         groupBy: "tag:HP",
+                        showInsertionText: true,
+                        showDeletionText: true,
                         showSoftClips: {{track.show_soft_clips | lower }},
                         format: "{{ track.format }}",
                         height: "{{track.height}}"

scout/server/blueprints/cases/controllers.py

@@ -371,7 +371,7 @@ def case(
     partial_causatives = _get_partial_causatives(store, institute_obj, case_obj)
     _populate_assessments(partial_causatives)
 
-    case_obj["clinvar_variants"] = store.case_to_clinVars(case_obj["_id"])
+    case_obj["clinvar_variants"] = store.case_to_clinvars(case_obj["_id"])
 
     # check for variants submitted to clinVar but not present in suspects for the case
     clinvar_variants_not_in_suspects = [

scout/server/blueprints/cases/templates/cases/case_report.html

@@ -700,11 +700,28 @@
         <tbody>
           <tr>
             <td>{{ variant.sift_predictions|join(', ') or '-'}}</td>
-            <td>{{ variant.revel or '-' }}</td>
+            <td>
+              {% if variant.revel %}
+                <span class="badge bg-{{variant.revel|get_label_or_color_by_score('revel', 'color')}}">
+                  {{ variant.revel }}
+                </span>
+              {% else %}
+                <span class="badge bg-secondary">–</span>
+              {% endif %}
+            </td>
             <td>{{ variant.revel_score or '-' }}</td>
             <td>{{ variant.polyphen_predictions|join(', ') or '-' }}</td>
             <td>{{ variant.spidex|spidex_human if variant.spidex else none|spidex_human }}</td>
-            <td>{{ variant.spliceai_scores|join(', ') or '-' }}</td>
+            <td>
+              {% set spliceai_highest = variant.spliceai_scores | spliceai_max %}
+              {% if spliceai_highest %}
+                <span class="badge bg-{{ spliceai_highest | get_label_or_color_by_score('spliceai', 'color') }}">
+                  {{ variant.spliceai_scores|join(', ') }}
+                </span>
+              {% else %}
+                <span class="badge bg-secondary">–</span>
+              {% endif %}
+            </td>
           </tr>
         </tbody>
       </table>