scout-browser 4.81__py3-none-any.whl → 4.82.2__py3-none-any.whl

scout/__version__.py

@@ -1 +1 @@
-__version__ = "4.81"
+__version__ = "4.82.2"

scout/adapter/mongo/disease_terms.py

@@ -10,6 +10,9 @@ from scout.exceptions import IntegrityError
 LOG = logging.getLogger(__name__)
 
 DISEASE_FILTER_PROJECT = {"hpo_terms": 0, "genes": 0}
+REGEX = "$regex"
+REGEX_OPTIONS = "$options"
+REGEX_IGNORECASE = "i"
 
 
 class DiagnosisHandler(object):
@@ -32,8 +35,8 @@ class DiagnosisHandler(object):
         if query:
             query_dict = {
                 "$or": [
-                    {"disease_nr": {"$regex": query, "$options": "i"}},
-                    {"description": {"$regex": query, "$options": "i"}},
+                    {"disease_id": {REGEX: query, REGEX_OPTIONS: REGEX_IGNORECASE}},
+                    {"description": {REGEX: query, REGEX_OPTIONS: REGEX_IGNORECASE}},
                 ]
             }
             # If source is specified, add this restriction to the query

scout/adapter/mongo/query.py

@@ -11,6 +11,8 @@ from scout.constants import (
     TRUSTED_REVSTAT_LEVEL,
 )
 
+CRITERION_EXCLUDE_OPERATOR = {False: "$in", True: "$nin"}
+
 LOG = logging.getLogger(__name__)
 
 
@@ -256,7 +258,11 @@ class QueryHandler(object):
             if criterion in ["hgnc_symbols", "gene_panels"]:
                 gene_query = self.gene_filter(query, build=build)
                 if len(gene_query) > 0 or "hpo" in query.get("gene_panels", []):
-                    mongo_query["hgnc_ids"] = {"$in": gene_query}
+                    mongo_query["hgnc_ids"] = {
+                        CRITERION_EXCLUDE_OPERATOR[
+                            bool(query.get("gene_panels_exclude"))
+                        ]: gene_query
+                    }
                 continue
 
             if criterion == "chrom" and query.get("chrom"):  # filter by coordinates
@@ -352,6 +358,7 @@ class QueryHandler(object):
                 mongo_query["$and"] = coordinate_query + mongo_query["$and"]
             else:
                 mongo_query["$and"] = coordinate_query
+
         return mongo_query
 
     def affected_inds_query(self, mongo_query, case_id, gt_query):
@@ -572,16 +579,21 @@ class QueryHandler(object):
                     }
                 )
 
-            if criterion == "local_obs":
-                local_obs = query.get("local_obs")
-                mongo_secondary_query.append(
-                    {
-                        "$or": [
-                            {"local_obs_old": None},
-                            {"local_obs_old": {"$lt": local_obs + 1}},
-                        ]
-                    }
-                )
+            for local_obs_old_type in [
+                "local_obs_old",
+                "local_obs_cancer_germline_old",
+                "local_obs_cancer_somatic_old",
+            ]:
+                if criterion == local_obs_old_type:
+                    local_obs = query.get(local_obs_old_type)
+                    mongo_secondary_query.append(
+                        {
+                            "$or": [
+                                {local_obs_old_type: None},
+                                {local_obs_old_type: {"$lt": local_obs + 1}},
+                            ]
+                        }
+                    )
 
             if criterion == "local_obs_freq":
                 local_obs_freq = query.get("local_obs_freq")

scout/build/managed_variant.py

@@ -1,4 +1,7 @@
 import logging
+
+from flask import flash
+
 from scout.models.managed_variant import ManagedVariant
 
 LOG = logging.getLogger(__name__)
@@ -32,7 +35,15 @@ def build_managed_variant(managed_variant_info):
             description=managed_variant_info.get("description", ""),
         )
     except KeyError:
-        raise KeyError("Managed variant has to have chr, pos, ref and alt.")
+        flash(
+            "Managed variant has to have chr, pos, ref and alt",
+            "danger",
+        )
+    except ValueError as ve:
+        flash(
+            "Could not build managed variant {}".format(ve),
+            "danger",
+        )
 
     LOG.debug("Built managed variant %s", managed_variant.get("display_id"))
 

scout/build/variant/genotype.py

@@ -14,6 +14,7 @@ def build_genotype(gt_call):
         allele_depths = list, # int
         read_depth = int,
         genotype_quality = int,
+        alt_mc = int, # STR
         so = str, # STR type of reads that support allele: "a/a" where a in [SPANNING, FLANKING, INREPEAT]
     )
 
@@ -27,6 +28,7 @@ def build_genotype(gt_call):
         alt_frequency=gt_call["alt_frequency"] or -1,
         genotype_quality=gt_call["genotype_quality"],
         so=gt_call["so"],
+        alt_mc=gt_call["alt_mc"],
         ffpm=gt_call["ffpm"],
         split_read=gt_call["split_read"],
     )

scout/build/variant/variant.py

@@ -199,7 +199,12 @@ def build_variant(
     variant_obj["str_pathologic_min"] = variant.get("str_pathologic_min")
     variant_obj["str_ref"] = variant.get("str_ref")
     variant_obj["str_repid"] = variant.get("str_repid")
+    variant_obj["str_trid"] = variant.get("str_trid")
+    variant_obj["str_pathologic_struc"] = variant.get("str_pathologic_struc")
+    variant_obj["str_struc"] = variant.get("str_struc")
+    variant_obj["str_motifs"] = variant.get("str_motifs")
     variant_obj["str_ru"] = variant.get("str_ru")
+    variant_obj["str_display_ru"] = variant.get("str_display_ru")
     variant_obj["str_source"] = variant.get("str_source")
     variant_obj["str_status"] = variant.get("str_status")
     variant_obj["str_swegen_mean"] = call_safe(float, variant.get("str_swegen_mean"))

scout/constants/clinvar.py

@@ -184,7 +184,7 @@ CONDITION_PREFIX = {
     "MeSH": "",
     "MONDO": "MONDO:",
     "OMIM": "",
-    "Orphanet": "ORPHA:",
+    "Orphanet": "ORPHA",
 }
 
 CLINVAR_ASSERTION_METHOD_CIT_DB_OPTIONS = {"DOI", "pmc", "PMID"}

scout/constants/query_terms.py

@@ -31,7 +31,9 @@ PRIMARY_CRITERIA = ["clinsig"]
 # such as a Pathogenic ClinSig.
 SECONDARY_CRITERIA = [
     "gnomad_frequency",
-    "local_obs",
+    "local_obs_old",
+    "local_obs_cancer_somatic_old",
+    "local_obs_cancer_germline_old",
     "local_obs_freq",
     "clingen_ngi",
     "swegen",

scout/models/variant/variant.py

@@ -112,6 +112,7 @@ gt_call = dict(
     genotype_call=str,
     allele_depths=list,  # int
     read_depth=int,
+    alt_mc=int,
     genotype_quality=int,
     so=str,
 )

scout/parse/variant/frequency.py

@@ -2,7 +2,41 @@ from typing import Dict
 
 import cyvcf2
 
-swegen_keys = ["swegen", "swegenAF", "SWEGENAF"]
+# SNV
+SWEGEN_KEYS = ["swegen", "swegenAF", "SWEGENAF"]
+THOUSAND_GENOMES_KEYS = ["1000GAF"]
+THOUSAND_GENOMES_MAX_KEYS = ["1000G_MAX_AF"]
+
+EXAC_KEYS = ["EXACAF"]
+EXAC_MAX_KEYS = ["ExAC_MAX_AF", "EXAC_MAX_AF"]
+
+# gnomAD has both SNV and SV
+GNOMAD_INFO_KEYS = ["GNOMADAF", "GNOMAD_AF", "gnomADg_AF", "gnomad_svAF"]
+GNOMAD_INFO_MAX_KEYS = ["gnomADg_AF_POPMAX", "GNOMADAF_popmax", "GNOMADAF_POPMAX", "GNOMADAF_MAX"]
+
+# SV
+CLINGEN_BENIGN_KEYS = [
+    "clingen_cgh_benignAF",
+    "clingen_cgh_benign",
+    "clingen_cgh_benignOCC",
+]
+
+CLINGEN_PATHOGENIC_KEYS = [
+    "clingen_cgh_pathogenicAF",
+    "clingen_cgh_pathogenic",
+    "clingen_cgh_pathogenicOCC",
+]
+
+CLINGEN_NGI_KEYS = ["clingen_ngi", "clingen_ngiAF", "clingen_ngiOCC"]
+
+DECIPHER_KEYS = ["decipherAF", "decipher"]
+CG_KEYS = ["clinical_genomics_mipAF", "clinical_genomics_mipOCC"]
+
+# MEI
+SWEGEN_ALU_KEYS = ["swegen_alu_FRQ", "swegen_alu_OCC"]
+SWEGEN_HERV_KEYS = ["swegen_herv_FRQ", "swegen_herv_OCC"]
+SWEGEN_L1_KEYS = ["swegen_l1_FRQ", "swegen_l1_OCC"]
+SWEGEN_SVA_KEYS = ["swegen_sva_FRQ", "swegen_sva_OCC"]
 
 
 def parse_frequencies(variant, transcripts):
@@ -19,37 +53,27 @@ def parse_frequencies(variant, transcripts):
         frequencies(dict): A dictionary with the relevant frequencies
     """
     frequencies = {}
-    # These lists could be extended...
-    thousand_genomes_keys = ["1000GAF"]
-    thousand_genomes_max_keys = ["1000G_MAX_AF"]
-
-    exac_keys = ["EXACAF"]
-    exac_max_keys = ["ExAC_MAX_AF", "EXAC_MAX_AF"]
 
-    # Gnomad have both snv and sv frequencies
-    gnomad_keys = ["GNOMADAF", "GNOMAD_AF", "gnomad_svAF"]
-    gnomad_max_keys = ["GNOMADAF_popmax", "GNOMADAF_POPMAX", "GNOMADAF_MAX"]
-
-    update_frequency_from_vcf(frequencies, variant, exac_keys, "exac")
-    update_frequency_from_vcf(frequencies, variant, exac_max_keys, "exac_max")
-    update_frequency_from_vcf(frequencies, variant, gnomad_keys, "gnomad")
-    update_frequency_from_vcf(frequencies, variant, swegen_keys, "swegen")
-    update_frequency_from_vcf(frequencies, variant, gnomad_max_keys, "gnomad_max")
-    update_frequency_from_vcf(frequencies, variant, thousand_genomes_keys, "thousand_g")
-    update_frequency_from_vcf(frequencies, variant, thousand_genomes_max_keys, "thousand_g_max")
+    update_frequency_from_vcf(frequencies, variant, EXAC_KEYS, "exac")
+    update_frequency_from_vcf(frequencies, variant, EXAC_MAX_KEYS, "exac_max")
+    update_frequency_from_vcf(frequencies, variant, GNOMAD_INFO_KEYS, "gnomad")
+    update_frequency_from_vcf(frequencies, variant, SWEGEN_KEYS, "swegen")
+    update_frequency_from_vcf(frequencies, variant, GNOMAD_INFO_MAX_KEYS, "gnomad_max")
+    update_frequency_from_vcf(frequencies, variant, THOUSAND_GENOMES_KEYS, "thousand_g")
+    update_frequency_from_vcf(frequencies, variant, THOUSAND_GENOMES_MAX_KEYS, "thousand_g_max")
 
     # For mitochondrial variants, keep both "hom" and "het" freqs
     update_frequency_from_vcf(frequencies, variant, ["GNOMAD_MT_AF_HOM"], "gnomad_mt_homoplasmic")
     update_frequency_from_vcf(frequencies, variant, ["GNOMAD_MT_AF_HET"], "gnomad_mt_heteroplasmic")
 
-    # Search transcripts if not found in VCF
-    if not frequencies:
-        update_frequency_from_transcript(frequencies, transcripts)
-
     # These are SV-specific frequencies
     update_frequency_from_vcf(frequencies, variant, ["left_1000GAF"], "thousand_g_left")
     update_frequency_from_vcf(frequencies, variant, ["right_1000GAF"], "thousand_g_right")
 
+    # Search transcripts CSQ if not found in VCF INFO
+    if not frequencies:
+        update_frequency_from_transcript(frequencies, transcripts)
+
     return frequencies
 
 
@@ -85,31 +109,14 @@ def parse_sv_frequencies(variant: cyvcf2.Variant) -> Dict:
     """
     sv_frequencies = {}
 
-    clingen_benign_keys = [
-        "clingen_cgh_benignAF",
-        "clingen_cgh_benign",
-        "clingen_cgh_benignOCC",
-    ]
-
-    clingen_pathogenic_keys = [
-        "clingen_cgh_pathogenicAF",
-        "clingen_cgh_pathogenic",
-        "clingen_cgh_pathogenicOCC",
-    ]
-
-    clingen_ngi_keys = ["clingen_ngi", "clingen_ngiAF", "clingen_ngiOCC"]
-
-    decipher_keys = ["decipherAF", "decipher"]
-    cg_keys = ["clinical_genomics_mipAF", "clinical_genomics_mipOCC"]
-
-    update_sv_frequency_from_vcf(sv_frequencies, variant, clingen_benign_keys, "clingen_cgh_benign")
+    update_sv_frequency_from_vcf(sv_frequencies, variant, CLINGEN_BENIGN_KEYS, "clingen_cgh_benign")
     update_sv_frequency_from_vcf(
-        sv_frequencies, variant, clingen_pathogenic_keys, "clingen_cgh_pathogenic"
+        sv_frequencies, variant, CLINGEN_PATHOGENIC_KEYS, "clingen_cgh_pathogenic"
     )
-    update_sv_frequency_from_vcf(sv_frequencies, variant, clingen_ngi_keys, "clingen_ngi")
-    update_sv_frequency_from_vcf(sv_frequencies, variant, swegen_keys, "swegen")
-    update_sv_frequency_from_vcf(sv_frequencies, variant, decipher_keys, "decipher")
-    update_sv_frequency_from_vcf(sv_frequencies, variant, cg_keys, "clingen_mip")
+    update_sv_frequency_from_vcf(sv_frequencies, variant, CLINGEN_NGI_KEYS, "clingen_ngi")
+    update_sv_frequency_from_vcf(sv_frequencies, variant, SWEGEN_KEYS, "swegen")
+    update_sv_frequency_from_vcf(sv_frequencies, variant, DECIPHER_KEYS, "decipher")
+    update_sv_frequency_from_vcf(sv_frequencies, variant, CG_KEYS, "clingen_mip")
 
     return sv_frequencies
 
@@ -117,17 +124,12 @@ def parse_sv_frequencies(variant: cyvcf2.Variant) -> Dict:
 def parse_mei_frequencies(variant: cyvcf2.Variant) -> Dict:
     """Parsing of some custom mei frequencies."""
 
-    swegen_alu_keys = ["swegen_alu_FRQ", "swegen_alu_OCC"]
-    swegen_herv_keys = ["swegen_herv_FRQ", "swegen_herv_OCC"]
-    swegen_l1_keys = ["swegen_l1_FRQ", "swegen_l1_OCC"]
-    swegen_sva_keys = ["swegen_sva_FRQ", "swegen_sva_OCC"]
-
     mei_frequencies = {}
 
-    update_sv_frequency_from_vcf(mei_frequencies, variant, swegen_alu_keys, "swegen_alu")
-    update_sv_frequency_from_vcf(mei_frequencies, variant, swegen_herv_keys, "swegen_herv")
-    update_sv_frequency_from_vcf(mei_frequencies, variant, swegen_l1_keys, "swegen_l1")
-    update_sv_frequency_from_vcf(mei_frequencies, variant, swegen_sva_keys, "swegen_sva")
+    update_sv_frequency_from_vcf(mei_frequencies, variant, SWEGEN_ALU_KEYS, "swegen_alu")
+    update_sv_frequency_from_vcf(mei_frequencies, variant, SWEGEN_HERV_KEYS, "swegen_herv")
+    update_sv_frequency_from_vcf(mei_frequencies, variant, SWEGEN_L1_KEYS, "swegen_l1")
+    update_sv_frequency_from_vcf(mei_frequencies, variant, SWEGEN_SVA_KEYS, "swegen_sva")
 
     if any(mei_frequencies.values()):
         max_mei_frequency = max(mei_frequencies.values())

scout/parse/variant/genotype.py

@@ -19,7 +19,7 @@ Uses 'DV' to describe number of paired ends that supports the event and
 """
 
 import logging
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 import cyvcf2
 
@@ -103,6 +103,14 @@ def parse_genotype(variant, ind, pos):
     (flanking_ref, flanking_alt) = _parse_format_entry(variant, pos, "ADFL")
     (inrepeat_ref, inrepeat_alt) = _parse_format_entry(variant, pos, "ADIR")
 
+    # TRGT long read STR specific
+    (_, 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)
+    (ap_ref, ap_alt) = _parse_format_entry(variant, pos, "AP", float)
+    (am_ref, am_alt) = _parse_format_entry(variant, pos, "AM", float)
+
     # MEI specific
     (spanning_mei_ref, clip5_alt, clip3_alt) = get_mei_reads(
         variant, pos
@@ -395,33 +403,48 @@ def get_str_so(variant, pos):
     return str_so
 
 
-def _parse_format_entry(variant, pos, format_entry_name):
-    """Parse genotype format entry for named integer values.
-    Expects that ref/alt values could be separated by /.
+def split_values(values: List[str]) -> List[str]:
+    """
+    Expects that ref/alt values could be separated by "/" or ",".
 
-    Args:
-        variant(cyvcf2.Variant)
-        pos(int): individual position in VCF
-        format_entry_name: name of format entry
-    Returns:
-        (ref(int), alt(int)) tuple
+    """
+    new_values = []
+    for value in values:
+        for delim in ["/", ","]:
+            if delim in value:
+                new_values = list(value.split(delim))
+
+    if new_values:
+        return new_values
+
+    return values
+
+
+def _parse_format_entry(
+    variant: cyvcf2.Variant,
+    pos: int,
+    format_entry_name: str,
+    number_format: Optional[Union[float, int]] = int,
+) -> Tuple[Union[float, int], ...]:
+    """Parse genotype format entry for named integer values.
+    Expects that ref/alt values could be separated by "/" or ",".
+    Give individual position in VCF as pos and name of format entry to parse as format_entry_name.
     """
 
     ref = None
     alt = None
     if format_entry_name in variant.FORMAT:
         try:
-            value = variant.format(format_entry_name)[pos]
-            values = list(value.split("/"))
+            values = split_values(variant.format(format_entry_name)[pos])
 
             ref_value = None
             alt_value = None
 
             if len(values) > 1:
-                ref_value = int(values[0])
-                alt_value = int(values[1])
+                ref_value = (number_format)(values[0])
+                alt_value = (number_format)(values[1])
             if len(values) == 1:
-                alt_value = int(values[0])
+                alt_value = (number_format)(values[0])
             if ref_value >= 0:
                 ref = ref_value
             if alt_value >= 0:
@@ -429,3 +452,54 @@ def _parse_format_entry(variant, pos, format_entry_name):
         except (ValueError, TypeError) as _ignore_error:
             pass
     return (ref, alt)
+
+
+def _parse_format_entry_trgt_mc(variant: cyvcf2.Variant, pos: int):
+    """Parse genotype entry for TRGT FORMAT MC
+
+    The MC format contains the Motif Counts for each allele, separated with "," and each motif in an expansion,
+    as a "_" separated list of the different available enumerated motifs. For some loci,
+    only certain motifs count towards a pathologic size, and if so a PathologicStruc INFO key is passed.
+    E.g. for non-reference motifs and more complex loci or alleles with different motifs.
+    As usual, VCF lines are decomposed, so at most one alt is present per entry.
+    The GT position gives us a ref index for any allele 0 in the call.
+    """
+
+    mc_ref = None
+    mc_alt = None
+
+    if "MC" not in variant.FORMAT:
+        return (mc_ref, mc_alt)
+
+    mc = variant.format("MC")[pos]
+    if not mc:
+        return (mc_ref, mc_alt)
+
+    ref_idx = None
+    gt = variant.genotypes[pos]
+    if gt:
+        for idx, allele in enumerate(gt):
+            if allele == 0:
+                ref_idx = idx
+
+    pathologic_struc = variant.INFO.get("PathologicStruc", None)
+    pathologic_counts = 0
+    for idx, allele in enumerate(mc.split(",")):
+        mcs = allele.split("_")
+
+        if len(mcs) > 1:
+            pathologic_mcs = pathologic_struc or range(len(mcs))
+
+            for index, count in enumerate(mcs):
+                if index in pathologic_mcs:
+                    pathologic_counts += int(count)
+        else:
+            pathologic_counts = int(allele)
+
+        if ref_idx is not None and idx == ref_idx:
+            mc_ref = pathologic_counts
+            continue
+
+        mc_alt = pathologic_counts
+
+    return (mc_ref, mc_alt)

scout/parse/variant/transcript.py

@@ -5,6 +5,10 @@ from scout.constants import SO_TERMS
 
 LOG = logging.getLogger(__name__)
 
+# gnomAD transcript CSQ keys. Use plain (older) AF if available. For a secondary choice, prefer genomes over exomes.
+GNOMAD_CSQ_KEYS = ["GNOMAD_AF", "GNOMADG_AF", "GNOMAD_EXOMES_AF"]
+THOUSAND_GENOMES_CSQ_KEYS = ["AF", "1000GAF", "1000GP3_AF"]
+
 
 def parse_transcripts(raw_transcripts):
     """Parse transcript information from VCF variants
@@ -303,6 +307,10 @@ def set_variant_frequencies(transcript, entry):
     * 'gnomAD_AF' - gnomAD exomes, all populations combined
     * 'gnomAD_xxx_AF' - gnomAD exomes, individual populations
     * 'MAX_AF' - Max of all populations (1000G, gnomAD exomes, ESP)
+    In VEP 107/111 keys are
+    * 'gnomADg_AF' - genomes
+    * 'gnomAD_exomes_AF' - exomes
+    * 1000GP3_AF - 1000G Phase 3
 
     Reference: https://www.ensembl.org/info/docs/tools/vep/vep_formats.html
     """
@@ -312,30 +320,30 @@ def set_variant_frequencies(transcript, entry):
     try:
         for key in entry:
             # All frequencies endswith AF
-            if not key.endswith("AF"):
+            if not (key.endswith("AF") or key.endswith("POPMAX")):
                 continue
 
             value = entry[key]
-            if not value:
+            if not value or value == ".":
                 continue
 
-            # This is the 1000G max af information
-            if key == "AF" or key == "1000GAF":
+            if key in THOUSAND_GENOMES_CSQ_KEYS:
                 transcript["thousand_g_maf"] = float(value)
                 continue
 
-            if key == "GNOMAD_AF":
-                transcript["gnomad_maf"] = float(value)
-                continue
+            for gnomad_ordered_key in GNOMAD_CSQ_KEYS:
+                if key == gnomad_ordered_key:
+                    transcript["gnomad_maf"] = float(value)
+                    break
 
             if key == "EXAC_MAX_AF":
                 transcript["exac_max"] = float(value)
                 transcript["exac_maf"] = float(value)
                 continue
 
+            # remaining gnomAD or 1000G subpopulation frequencies and/or popmax values
             if "GNOMAD" in key:
                 gnomad_freqs.append(float(value))
-
             else:
                 thousandg_freqs.append(float(value))
 
@@ -354,4 +362,4 @@ def set_variant_frequencies(transcript, entry):
         )
         LOG.debug("Exception details", exc_info=True)
         LOG.debug("Current entry: %s", entry)
-        LOG.warning("Only splitted and normalised VEP v90+ frequencies are supported")
+        LOG.warning("Only decomposed/split and normalised VEP v90+ frequencies are supported")

scout/parse/variant/variant.py

@@ -393,6 +393,18 @@ def set_str_info(variant: Variant, parsed_variant: Dict[str, Any]):
     # repeat id generally corresponds to gene symbol
     parsed_variant["str_repid"] = call_safe(str, variant.INFO.get("REPID"))
 
+    # repeat id from trgt - generally corresponds to gene symbol and/or disease
+    parsed_variant["str_trid"] = call_safe(str, variant.INFO.get("TRID"))
+
+    # repeat unit - used e g in PanelApp naming of STRs
+    parsed_variant["str_struc"] = call_safe(str, variant.INFO.get("STRUC"))
+
+    # repeat motif(s) - used e g in TRGT MC motif splits
+    parsed_variant["str_motifs"] = call_safe(str, variant.INFO.get("MOTIFS"))
+
+    # repeat pathologic motifs structure - list of indicies of pathologic motifs counting towards MC
+    parsed_variant["str_pathologic_struc"] = call_safe(str, variant.INFO.get("PathologicStruc"))
+
     # repeat unit - used e g in PanelApp naming of STRs
     parsed_variant["str_ru"] = call_safe(str, variant.INFO.get("RU"))
 

scout/server/app.py

@@ -1,4 +1,5 @@
 """Code for flask app"""
+
 import logging
 import os
 from datetime import timedelta
@@ -10,7 +11,7 @@ from flask import Flask, current_app, redirect, request, url_for
 from flask_babel import Babel
 from flask_cors import CORS
 from flask_login import current_user
-from flaskext.markdown import Markdown
+from markdown import markdown as python_markdown
 from markupsafe import Markup
 
 from . import extensions
@@ -109,8 +110,6 @@ def configure_extensions(app):
     extensions.login_manager.init_app(app)
     extensions.mail.init_app(app)
 
-    Markdown(app)
-
     if app.config.get("SQLALCHEMY_DATABASE_URI"):
         LOG.info("Chanjo extension enabled")
         configure_coverage(app)
@@ -227,6 +226,10 @@ def register_filters(app):
         # round all other numbers
         return round(number, ndigits)
 
+    @app.template_filter()
+    def markdown(text: str) -> Markup:
+        return Markup(python_markdown(text))
+
     @app.template_filter()
     def tuple_list_to_dict(tuple_list, key_elem, value_elem):
         """Accepts a list of tuples and returns a dictionary with tuple element = key_elem as keys and tuple element = value_elem as values"""

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

@@ -1,5 +1,5 @@
 {% macro igv_script() %}
   <link rel="shortcut icon" href="//igv.org/web/img/favicon.ico">
   <!-- IGV JS-->
-  <script src="https://cdn.jsdelivr.net/npm/igv@2.15.8/dist/igv.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/igv@2.15.11/dist/igv.min.js"></script>
 {% endmacro %}