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

scout/server/config.py

@@ -75,10 +75,9 @@ ACCREDITATION_BADGE = "swedac-1926-iso17025.png"
 # Connection details for Scout REViewer service
 # SCOUT_REVIEWER_URL = "http://127.0.0.1:8000/reviewer"
 
-#
-# Cloud IGV tracks can be configured here to allow users to enable them on their IGV views.
-# A number of publicly-available tracks can be found here: https://trackhubregistry.org/
-# CLOUD_IGV_TRACKS = [
+# Custom IGV tracks can be configured here to allow users to enable them on their IGV views.
+# A number of publicly-available tracks can be found here: https://trackhubregistry.org/ or downloaded from
+# CUSTOM_IGV_TRACKS = [
 #    {
 #        "name": "public_tracks",
 #        "access": "public",
@@ -99,6 +98,19 @@ ACCREDITATION_BADGE = "swedac-1926-iso17025.png"
 #            },
 #        ],
 #    },
+#    {
+#        "name": "local_tracks",
+#        "access": "public",
+#        "tracks": [
+#            {
+#                "name": "MANE",
+#                "type": "annotation",
+#                "format": "bigbed",
+#                "build": "38",
+#                "url": "scout/resources/custom_igv_tracks/mane.bb",
+#            },
+#        ],
+#    },
 # ]
 
 # Chanjo-Report

scout/server/extensions/__init__.py

@@ -6,10 +6,11 @@ from flask_login import LoginManager
 from flask_mail import Mail
 
 from scout.adapter import MongoAdapter
-from scout.utils.cloud_resources import AlignTrackHandler
+from scout.utils.track_resources import AlignTrackHandler
 
 from .beacon_extension import Beacon
 from .bionano_extension import BioNanoAccessAPI
+from .chanjo_extension import ChanjoReport
 from .clinvar_extension import ClinVarApi
 from .gens_extension import GensViewer
 from .ldap_extension import LdapManager
@@ -33,5 +34,6 @@ phenopacketapi = PhenopacketAPI()
 rerunner = RerunnerService()
 matchmaker = MatchMaker()
 beacon = Beacon()
-cloud_tracks = AlignTrackHandler()
+config_igv_tracks = AlignTrackHandler()
 bionano_access = BioNanoAccessAPI()
+chanjo_report = ChanjoReport()

scout/server/extensions/beacon_extension.py

@@ -1,6 +1,7 @@
 """Scout supports integration with the Clinical Genomics SciLifeLab Beacon
    cgbeacon2: https://github.com/Clinical-Genomics/cgbeacon2
 """
+
 import datetime
 import logging
 

scout/server/extensions/bionano_extension.py

@@ -6,6 +6,7 @@
     For further development, the server has a Swagger-like demo interface at https://bionano-access.scilifelab.se/Bnx/
     which is useful for details, and for sniffing actual message content structure, required cookie variable names etc.
 """
+
 import json
 import logging
 from typing import Dict, Iterable, List, Optional, Tuple

scout/server/extensions/chanjo_extension.py

@@ -0,0 +1,59 @@
+"""
+    Generate coverage reports using chanjo and chanjo-report. Documentation under -> `docs/admin-guide/chanjo_coverage_integration.md`
+"""
+
+import logging
+
+from flask import current_app, request
+from flask_babel import Babel
+from markupsafe import Markup
+
+LOG = logging.getLogger(__name__)
+
+
+class ChanjoReport:
+    """Interfaces with chanjo-report. Creates the /reports endpoints in scout domain. Use Babel to set report language."""
+
+    def init_app(self, app):
+        try:
+            from chanjo_report.server.app import configure_template_filters
+            from chanjo_report.server.blueprints import report_bp
+            from chanjo_report.server.extensions import api as chanjo_api
+        except ImportError as error:
+            chanjo_api = None
+            report_bp = None
+            configure_template_filters = None
+            LOG.error(error)
+
+        if not chanjo_api:
+            raise ImportError(
+                "An SQL db path was given, but chanjo-report could not be registered."
+            )
+
+        def get_locale():
+            """Determine locale to use for translations."""
+            accept_languages = current_app.config.get("ACCEPT_LANGUAGES", ["en"])
+
+            # first check request args
+            session_language = Markup.escape(request.args.get("lang"))
+            if session_language in accept_languages:
+                current_app.logger.info("using session language: %s", session_language)
+                return session_language
+
+            # language can be forced in config
+            user_language = current_app.config.get("REPORT_LANGUAGE")
+            if user_language:
+                return user_language
+
+            # try to guess the language from the user accept header that
+            # the browser transmits.  We support de/fr/en in this example.
+            # The best match wins.
+            return request.accept_languages.best_match(accept_languages)
+
+        babel = Babel(app)
+        babel.init_app(app, locale_selector=get_locale)
+        chanjo_api.init_app(app)
+        configure_template_filters(app)
+        app.register_blueprint(report_bp, url_prefix="/reports")
+        app.config["chanjo_report"] = True
+        app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = True if app.debug else False

scout/server/extensions/gens_extension.py

@@ -2,6 +2,7 @@
 
 * Requires gens version 1.1.1 or greater
 """
+
 import logging
 
 LOG = logging.getLogger(__name__)

scout/server/extensions/ldap_extension.py

@@ -43,9 +43,11 @@ class LdapManager(LDAPConn):
         self.tls = Tls(
             local_private_key_file=app.config["LDAP_CLIENT_PRIVATE_KEY"],
             local_certificate_file=app.config["LDAP_CLIENT_CERT"],
-            validate=app.config["LDAP_REQUIRE_CERT"]
-            if app.config.get("LDAP_CLIENT_CERT")
-            else ssl.CERT_NONE,
+            validate=(
+                app.config["LDAP_REQUIRE_CERT"]
+                if app.config.get("LDAP_CLIENT_CERT")
+                else ssl.CERT_NONE
+            ),
             version=app.config["LDAP_TLS_VERSION"],
             ca_certs_file=app.config["LDAP_CA_CERTS_FILE"],
             valid_names=app.config["LDAP_VALID_NAMES"],

scout/server/extensions/loqus_extension.py

@@ -3,11 +3,15 @@
 * Requires loqusdb version 2.5 or greater.
 * If multiple instances are configured, version will be default's.
 """
+
 import json
 import logging
 import subprocess
 import traceback
 from subprocess import CalledProcessError
+from typing import Dict, Optional
+
+from flask import flash
 
 from scout.exceptions.config import ConfigError
 from scout.utils.scout_requests import get_request_json as api_get
@@ -180,16 +184,9 @@ class LoqusDB:
         }
         return loqus_query
 
-    def get_variant(self, variant_info, loqusdb_id="default"):
-        """Return information for a variant (SNV or SV) from loqusdb
-
-        Args:
-            variant_info(dict)
-            loqusdb_id(string)
+    def get_variant(self, variant_info: dict, loqusdb_id: str = "default") -> Optional[Dict]:
+        """Return information for a variant (SNV or SV) from loqusdb"""
 
-        Returns:
-            loqus_variant(dict)
-        """
         loqus_instance = self.loqusdb_settings.get(loqusdb_id)
         if loqus_instance is None:
             LOG.error(f"Could not find a Loqus instance with id:{loqusdb_id}")
@@ -202,7 +199,7 @@ class LoqusDB:
         return self.get_api_loqus_variant(loqus_instance.get(API_URL), variant_info)
 
     @staticmethod
-    def get_api_loqus_variant(api_url, variant_info):
+    def get_api_loqus_variant(api_url, variant_info) -> dict:
         """get variant data using a Loqus instance available via REST API
 
         SNV/INDELS can be queried in loqus by defining a simple id. For SVs we need to call them
@@ -230,10 +227,15 @@ class LoqusDB:
             search_url = f"{search_url}/?chrom={chrom}&end_chrom={end_chrom}&pos={pos}&end={end}&sv_type={sv_type}"
 
         search_resp = api_get(search_url)
-        if search_resp.get("status_code") != 200:
-            LOG.info(search_resp.get("detail"))
-            return {}
-        return search_resp.get("content")
+
+        if search_resp.get("status_code") == 200:
+            return search_resp.get("content")
+        if search_resp.get("message"):  # An error occurred during the request
+            flash(
+                f"Connection to Loqusdb instance returned error: '{search_resp['message']}'",
+                "warning",
+            )
+        return {}
 
     def get_exec_loqus_variant(self, loqus_instance, variant_info):
         """Get variant data using a local executable instance of Loqus

scout/server/extensions/matchmaker_extension.py

@@ -1,6 +1,7 @@
 """Code for MatchMaker Exchange integration
    Tested with PatientMatcher: https://github.com/Clinical-Genomics/patientMatcher
 """
+
 import datetime
 import json
 import logging

scout/server/extensions/mongo_extension.py

@@ -1,4 +1,5 @@
 """Code for flask mongodb extension in scout"""
+
 import os
 
 from scout.adapter.client import get_connection

scout/server/extensions/phenopacket_extension.py

@@ -3,6 +3,7 @@ Extension to Scout for Phenopacket integration (http://phenopackets.org).
 Write and read JSON Phenopackets, and interact with phenopacket-api backend
 (https://github.com/squeezeday/phenopacket-api).
 """
+
 import json as json_lib
 import logging
 

scout/server/extensions/rerunner_extension.py

@@ -1,4 +1,5 @@
 """Code for Rerunner integration."""
+
 import logging
 
 LOG = logging.getLogger(__name__)

scout/server/links.py

@@ -159,7 +159,7 @@ def genemania(hgnc_symbol):
 
 
 def genenames(hgnc_id):
-    link = "https://www.genenames.org/cgi-bin/gene_symbol_report?hgnc_id=HGNC:{}"
+    link = "https://www.genenames.org/data/gene-symbol-report/#!/hgnc_id/HGNC:{}"
     if not hgnc_id:
         return None
     return link.format(hgnc_id)
@@ -679,9 +679,9 @@ def snp_links(variant_obj):
         if "rs" in snp:
             snp_links[snp] = f"https://www.ncbi.nlm.nih.gov/snp/{snp}"  # dbSNP
         elif snp.isnumeric():
-            snp_links[
-                snp
-            ] = f"https://www.ncbi.nlm.nih.gov/clinvar/variation/{snp}"  # ClinVar variation
+            snp_links[snp] = (
+                f"https://www.ncbi.nlm.nih.gov/clinvar/variation/{snp}"  # ClinVar variation
+            )
 
     return snp_links
 

scout/server/static/bs_styles.css

@@ -333,7 +333,7 @@ body {
 
 /* Closed submenu icon */
 #sidebar-container .list-group .list-group-item[aria-expanded="false"] .submenu-icon::after {
-  content: " \f0d7";
+  content: " \f0da";
   font-family: "Font Awesome 5 Free", ui-monospace;
   font-weight: 900;
   display: inline;
@@ -342,7 +342,7 @@ body {
 }
 /* Opened submenu icon */
 #sidebar-container .list-group .list-group-item[aria-expanded="true"] .submenu-icon::after {
-  content: " \f0da";
+  content: " \f0d7";
   font-family: "Font Awesome 5 Free", ui-monospace;
   font-weight: 900;
   display: inline;
@@ -351,6 +351,24 @@ body {
 }
 /* end of sidebar-related stuff */
 
+/* Closed submenu icon - general case */
+.text-body[aria-expanded="false"] .collapse-icon::after {
+  content: " \f0da";
+  font-family: "Font Awesome 5 Free", ui-monospace;
+  font-weight: 900;
+  display: inline;
+  text-align: left;
+}
+/* Open submenu icon - general case */
+.text-body[aria-expanded="true"] .collapse-icon::after {
+  content: " \f0d7";
+  font-family: "Font Awesome 5 Free", ui-monospace;
+  font-weight: 900;
+  display: inline;
+  text-align: left;
+}
+/* end of sidebar-related stuff */
+
 option {
   width: 100%;
 }

scout/server/utils.py

@@ -206,12 +206,26 @@ def user_institutes(store, login_user):
     return institutes
 
 
+def case_has_mtdna_report(case_obj: dict):
+    """Display mtDNA report on the case sidebar only for some specific cases."""
+    if case_obj.get("track", "rare") == "cancer":
+        return
+    for ind in case_obj.get("individuals", []):
+        if ind.get("analysis_type") == "wts":
+            continue
+        case_obj["mtdna_report"] = True
+        return
+
+
 def case_has_chanjo_coverage(case_obj: dict):
     """Set case_obj["chanjo_coverage"] to True if there is an instance of chanjo available and case has coverage stats in chanjo."""
 
-    chanjo_instance: bool = bool(current_app.config.get("SQLALCHEMY_DATABASE_URI"))
+    chanjo_instance: bool = bool(current_app.config.get("chanjo_report"))
     if case_obj.get("track", "rare") != "cancer" and chanjo_instance:
-        case_obj["chanjo_coverage"] = True
+        for ind in case_obj.get("individuals", []):
+            if ind.get("analysis_type") != "wts":
+                case_obj["chanjo_coverage"] = True
+                return
 
 
 def case_has_chanjo2_coverage(case_obj: dict):

scout/utils/acmg.py

@@ -190,27 +190,40 @@ def get_acmg(acmg_terms):
     bs_terms = []
     # Collection of terms with supporting Benign evidence
     bp_terms = []
+
+    suffix_map = {
+        "_Strong": {"P": ps_terms, "B": bs_terms},
+        "_Moderate": {"P": pm_terms},
+        "_Supporting": {"P": pp_terms, "B": bp_terms},
+    }
+
+    prefix_map = {
+        "PS": ps_terms,
+        "PM": pm_terms,
+        "PP": pp_terms,
+        "BS": bs_terms,
+        "BP": bp_terms,
+    }
+
     for term in acmg_terms:
-        if term.endswith("_Strong"):
-            ps_terms.append(term)
-        elif term.endswith("_Moderate"):
-            pm_terms.append(term)
-        elif term.endswith("_Supporting"):
-            pp_terms.append(term)
-        elif term.startswith("PVS"):
-            pvs = True
-        elif term.startswith("PS"):
-            ps_terms.append(term)
-        elif term.startswith("PM"):
-            pm_terms.append(term)
-        elif term.startswith("PP"):
-            pp_terms.append(term)
-        elif term.startswith("BA"):
-            ba = True
-        elif term.startswith("BS"):
-            bs_terms.append(term)
-        elif term.startswith("BP"):
-            bp_terms.append(term)
+        for suffix, prefix_dict in suffix_map.items():
+            if term.endswith(suffix):
+                for prefix, term_list in prefix_dict.items():
+                    if term.startswith(prefix):
+                        term_list.append(term)
+                        break
+                break
+        else:
+            # Do we match any of the two standalone terms
+            if term.startswith("PVS"):
+                pvs = True
+            elif term.startswith("BA"):
+                ba = True
+            else:  # Check remaining prefixes if no suffix match or standalone criteria match
+                for prefix, term_list in prefix_map.items():
+                    if term.startswith(prefix):
+                        term_list.append(term)
+                        break
 
     # We need to start by checking for Pathogenecity
     pathogenic = is_pathogenic(pvs, ps_terms, pm_terms, pp_terms)

scout/utils/ensembl_rest_clients.py

@@ -1,4 +1,5 @@
 """Code for talking to ensembl rest API"""
+
 import logging
 from urllib.parse import urlencode
 

scout/utils/scout_requests.py

@@ -1,4 +1,5 @@
 """Code for performing requests"""
+
 import logging
 import urllib.request
 import zlib

scout/utils/sort.py

@@ -0,0 +1,21 @@
+from scout.constants import FILE_TYPE_MAP
+
+
+def get_load_priority(category: str = None, variant_type: str = None, file_type: str = None) -> int:
+    """
+    Returns most urgent, highest load priority (numerically the lowest prio number) for the given variables
+    from a FILE_TYPE_MAP dict of dicts. Helper useful in a sort function.
+    """
+    ordered_file_type_map = sorted(FILE_TYPE_MAP.items(), key=lambda ftm: ftm[1]["load_priority"])
+
+    for ftm in ordered_file_type_map:
+        if file_type and file_type != ftm[0]:
+            continue
+
+        if category and category != ftm[1]["category"]:
+            continue
+
+        if variant_type and variant_type != ftm[1]["variant_type"]:
+            continue
+
+        return ftm[1]["load_priority"]

scout/utils/track_resources.py

@@ -0,0 +1,70 @@
+# coding=UTF-8
+import logging
+import re
+from os.path import abspath, exists, isabs
+
+LOG = logging.getLogger(__name__)
+
+REQUIRED_FIELDS = ["name", "type", "url"]
+TRACK_KEYS = ["name", "type", "format", "url", "indexURL"]
+URL_PATTERN = re.compile("https?://")
+
+from typing import List
+
+
+class AlignTrackHandler:
+    """Class collecting external IGV tracks stored in the cloud"""
+
+    def init_app(self, app):
+        self.tracks = self.set_custom_tracks(
+            app.config.get("CUSTOM_IGV_TRACKS") or app.config.get("CLOUD_IGV_TRACKS")
+        )
+
+    def track_template(self, track_info: dict) -> dict:
+        """Provides the template for a VCF track object"""
+        track = {}
+
+        for key in TRACK_KEYS:
+            if key in track_info:
+                track[key] = track_info[key]
+
+        # Save track only of it contains the minimal required keys
+        if all(track.get(key) for key in REQUIRED_FIELDS):
+            return track
+        else:
+            raise FileNotFoundError(
+                f"One or more custom tracks specified in the config file could not be used, Please provide all required keys:{REQUIRED_FIELDS}"
+            )
+
+    def set_local_track_path(self, path: str) -> str:
+        """Returns the complete path to a local igv track file"""
+        if exists(path) and isabs(path):
+            return path
+        elif exists(path):
+            return abspath(path)
+        else:
+            raise FileNotFoundError(f"Could not verify path to IGV track:{path}")
+
+    def set_custom_tracks(self, track_dictionaries: List[dict]) -> dict:
+        """Return a list of IGV tracks collected from the config settings
+
+        Args:
+            track_dictionaries: a list of cloud bucket dictionaries containing IGV tracks, can be public or private
+        """
+        custom_tracks = {"37": [], "38": []}
+        # Loop over the bucket list and collect all public tracks
+        for track_category in track_dictionaries:
+            for track in track_category.get("tracks", []):
+                build = track.get("build")
+                if build not in ["37", "38"]:
+                    LOG.warning(
+                        "One or more IGV public tracks could not be used, Please provide a genome build ('37', '38') for it."
+                    )
+                    continue
+                track_obj = self.track_template(track)
+
+                if not URL_PATTERN.search(track_obj["url"]):  # It's a local file
+                    track_obj["url"] = self.set_local_track_path(track_obj["url"])
+
+                custom_tracks[build].append(track_obj)
+        return custom_tracks

{scout_browser-4.82.2.dist-info → scout_browser-4.84.dist-info}/METADATA

@@ -1,12 +1,10 @@
 Metadata-Version: 2.1
 Name: scout-browser
-Version: 4.82.2
+Version: 4.84
 Summary: Clinical DNA variant visualizer and browser.
 Home-page: https://github.com/Clinical-Genomics/scout
 Author: Måns Magnusson
 Author-email: mans.magnusson@scilifelab.se
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
@@ -16,6 +14,7 @@ Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Programming Language :: Python :: 3.6
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: werkzeug <3
 Requires-Dist: Flask >=2.0
 Requires-Dist: Flask-Bootstrap
@@ -338,5 +337,3 @@ be found in [CONTRIBUTING](CONTRIBUTING.md).
 [black-url]: https://github.com/psf/black
 [woke-image]: https://github.com/Clinical-Genomics/scout/actions/workflows/woke.yml/badge.svg
 [woke-url]: https://github.com/Clinical-Genomics/scout/actions/workflows/woke.yml
-
-