scout-browser 4.98.0__py3-none-any.whl → 4.100.0__py3-none-any.whl

scout/parse/variant/variant.py

@@ -3,13 +3,13 @@ from typing import Any, Dict, List, Optional
 
 from cyvcf2 import Variant
 
-from scout.constants import CHR_PATTERN
+from scout.constants import CHR_PATTERN, DNA_SAMPLE_VARIANT_CATEGORIES
 from scout.exceptions import VcfError
 from scout.utils.convert import call_safe
 from scout.utils.dict_utils import remove_nonetype
 
 from .callers import parse_callers
-from .clnsig import parse_clnsig
+from .clnsig import parse_clnsig, parse_clnsig_onc
 from .compound import parse_compounds
 from .conservation import parse_conservations
 from .coordinates import parse_coordinates
@@ -57,15 +57,39 @@ def parse_variant(
     # Vep information
     vep_header = vep_header or []
 
-    parsed_variant = {}
     # Create the ID for the variant
     case_id = case["_id"]
+
     genmod_key = get_genmod_key(case)
     chrom_match = CHR_PATTERN.match(variant.CHROM)
     chrom = chrom_match.group(2)
 
+    ### We always assume split and normalized vcfs!!!
+    if len(variant.ALT) > 1:
+        raise VcfError("Variants are only allowed to have one alternative")
+
     # Builds a dictionary with the different ids that are used
-    alt = get_variant_alternative(variant, category)
+    parsed_variant = {
+        "case_id": case_id,
+        "variant_type": variant_type,
+        "reference": variant.REF,
+        "quality": variant.QUAL,  # cyvcf2 will set QUAL to None if '.' in vcf
+        "filters": get_filters(variant),
+        "chromosome": chrom,
+        "compounds": parse_compounds(
+            compound_info=variant.INFO.get("Compounds"),
+            case_id=genmod_key,
+            variant_type=variant_type,
+        ),
+        "rank_score": parse_rank_score(variant.INFO.get("RankScore", ""), 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")),
+        "somatic_score": call_safe(int, variant.INFO.get("SOMATICSCORE")),
+        "custom": parse_custom_data(variant.INFO.get("SCOUT_CUSTOM")),
+    }
+    category = get_and_set_category(parsed_variant, variant, category)
+    alt = get_and_set_variant_alternative(parsed_variant, variant, category)
 
     parsed_variant["ids"] = parse_ids(
         chrom=chrom,
@@ -75,71 +99,17 @@ def parse_variant(
         case_id=case_id,
         variant_type=variant_type,
     )
-    parsed_variant["case_id"] = case_id
-    # type can be 'clinical' or 'research'
-    parsed_variant["variant_type"] = variant_type
 
-    category = get_category(category, variant, parsed_variant)
-    parsed_variant["category"] = category
+    set_coordinates(parsed_variant, variant, case, category)
 
-    ################# General information #################
-    parsed_variant["reference"] = variant.REF
+    parsed_variant["samples"] = get_samples(variant, individual_positions, case, category)
 
-    ### We allways assume splitted and normalized vcfs!!!
-    if len(variant.ALT) > 1:
-        raise VcfError("Variants are only allowed to have one alternative")
-    parsed_variant["alternative"] = alt
-
-    # cyvcf2 will set QUAL to None if '.' in vcf
-    parsed_variant["quality"] = variant.QUAL
-
-    parsed_variant["filters"] = get_filters(variant)
-
-    # Add the dbsnp ids
     set_dbsnp_id(parsed_variant, variant.ID)
 
     # This is the id of other position in translocations
     # (only for specific svs)
     parsed_variant["mate_id"] = None
 
-    ################# Position specific #################
-    parsed_variant["chromosome"] = chrom
-
-    coordinates = parse_coordinates(variant, category, case.get("genome_build"))
-
-    parsed_variant["cytoband_end"] = coordinates["cytoband_end"]
-    parsed_variant["cytoband_start"] = coordinates["cytoband_start"]
-    parsed_variant["end"] = coordinates["end"]
-    parsed_variant["end_chrom"] = coordinates["end_chrom"]
-    parsed_variant["length"] = coordinates["length"]
-    parsed_variant["mate_id"] = coordinates["mate_id"]
-    parsed_variant["position"] = coordinates["position"]
-    parsed_variant["sub_category"] = coordinates["sub_category"]
-
-    ################# Add rank score #################
-    # The rank score is central for displaying variants in scout.
-    # Use RankScore for somatic variations also
-
-    rank_score = parse_rank_score(variant.INFO.get("RankScore", ""), genmod_key)
-    parsed_variant["rank_score"] = rank_score or 0
-
-    ################# Add gt calls #################
-    parsed_variant["samples"] = get_samples(variant, individual_positions, case)
-
-    ################# Add compound information #################
-    compounds = parse_compounds(
-        compound_info=variant.INFO.get("Compounds"),
-        case_id=genmod_key,
-        variant_type=variant_type,
-    )
-
-    parsed_variant["compounds"] = compounds
-
-    ################# Add inheritance patterns #################
-    parsed_variant["genetic_models"] = parse_genetic_models(
-        variant.INFO.get("GeneticModels"), genmod_key
-    )
-
     ################# Add autozygosity calls if present #################
     parsed_variant["azlength"] = call_safe(int, variant.INFO.get("AZLENGTH"))
     parsed_variant["azqual"] = call_safe(float, variant.INFO.get("AZQUAL"))
@@ -148,8 +118,6 @@ def parse_variant(
     set_str_info(variant, parsed_variant)
     # STR source dict with display string, source type and entry id
     set_str_source(parsed_variant, variant)
-    parsed_variant["str_swegen_mean"] = call_safe(float, variant.INFO.get("SweGenMean"))
-    parsed_variant["str_swegen_std"] = call_safe(float, variant.INFO.get("SweGenStd"))
 
     # MEI variant info
     set_mei_info(variant, parsed_variant)
@@ -157,18 +125,12 @@ def parse_variant(
     # Add Fusion info
     set_fusion_info(variant, parsed_variant)
 
-    ################# Add somatic info ##################
-    parsed_variant["somatic_score"] = call_safe(int, variant.INFO.get("SOMATICSCORE"))
-
     ################# Add mitomap info, from HmtNote #################
     set_mitomap_associated_diseases(parsed_variant, variant)
 
     ################# Add HmtVar variant id, from HmtNote #################
     add_hmtvar(parsed_variant, variant)
 
-    ### Add custom info
-    parsed_variant["custom"] = parse_custom_data(variant.INFO.get("SCOUT_CUSTOM"))
-
     ### Add gene and transcript information
     if parsed_variant.get("category") == "fusion":
         parsed_transcripts = add_gene_and_transcript_info_for_fusions(parsed_variant)
@@ -204,6 +166,25 @@ def parse_variant(
     return parsed_variant
 
 
+def set_coordinates(parsed_variant: dict, variant: dict, case: dict, category: str):
+    """
+    Parse and set coordinate annotations
+    """
+    coordinates = parse_coordinates(variant, category, case.get("genome_build"))
+    parsed_variant.update(
+        {
+            "cytoband_end": coordinates["cytoband_end"],
+            "cytoband_start": coordinates["cytoband_start"],
+            "end": coordinates["end"],
+            "end_chrom": coordinates["end_chrom"],
+            "length": coordinates["length"],
+            "mate_id": coordinates["mate_id"],
+            "position": coordinates["position"],
+            "sub_category": coordinates["sub_category"],
+        }
+    )
+
+
 def set_mei_specific_annotations(parsed_variant: dict, variant: dict):
     """Add MEI specific annotations"""
     if parsed_variant.get("category") in ["mei"]:
@@ -315,20 +296,15 @@ def get_genmod_key(case):
     return case["_id"]
 
 
-def get_variant_alternative(variant, category):
-    """Get variant's ALT
-
-    Args:
-        variant(cyvcf2.Variant)
-        category(str)
-    Return:
-        alternative variant: Str
-    """
+def get_and_set_variant_alternative(parsed_variant: dict, variant: Variant, category: str) -> str:
+    """Get and set variant's ALT as alternative"""
 
     if variant.ALT:
-        return variant.ALT[0]
+        alt = variant.ALT[0]
     elif not variant.ALT and category == "str":
-        return "."
+        alt = "."
+    parsed_variant["alternative"] = alt
+    return alt
 
 
 def set_mei_info(variant: Variant, parsed_variant: Dict[str, Any]):
@@ -378,42 +354,46 @@ def get_filters(variant):
     return ["PASS"]
 
 
-def get_samples(variant, individual_positions, case):
+def get_samples(variant: Variant, individual_positions: dict, case: dict, category: str) -> List:
     """Get samples
 
-    Args:
-        variant(cyvcf2.Variant)
-        individual_positions(dict):
-        case(dict)
-    Return:
-        variant filter
+    Add GT calls to individuals.
+
+    Do not add individuals if they are not wanted based on the analysis type,
+    eg a WTS only individual for a DNA SNV variant.
     """
-    if individual_positions and case["individuals"]:
-        return parse_genotypes(variant, case["individuals"], individual_positions)
+    invalid_sample_types: List[str] = []
+    if category in DNA_SAMPLE_VARIANT_CATEGORIES:
+        invalid_sample_types = ["wts"]
+
+    if individual_positions and bool(case["individuals"]):
+        individuals = [
+            ind
+            for ind in case["individuals"]
+            if ind.get("analysis_type") not in invalid_sample_types
+        ]
+        return parse_genotypes(variant, individuals, individual_positions)
     return []
 
 
-def get_category(category, variant, parsed_variant):
-    """Get category of variant.
-    Args:
-        category(str)
-        variant(cyvcf2.Variant)
-        parsed_variant(dict)
-    Return:
-        category(str)
+def get_and_set_category(parsed_variant: dict, variant: Variant, category: str) -> str:
+    """Set category of variant. Convenience return of category.
+
+    If category not set, use variant type, but convert types SNP or INDEL (or old MNP) to "snv".
     """
     if category:
+        parsed_variant["category"] = category
         return category
 
-    var_type = variant.var_type
-    if var_type == "indel":
-        return "snv"
-    if var_type == "snp":
-        return "snv"
-    if var_type == "mnp":
-        LOG.warning("Category MNP found: {}".format(parsed_variant["ids"]["display_name"]))
-        return "snv"
-    return var_type
+    category = variant.var_type
+    if category in ["indel", "snp"]:
+        category = "snv"
+    if category == "mnp":
+        category = "snv"
+        LOG.warning("Category MNP found for variant. Setting to SNV.")
+
+    parsed_variant["category"] = category
+    return category
 
 
 def set_dbsnp_id(parsed_variant, variant_id):
@@ -660,14 +640,13 @@ def set_clnsig(parsed_variant, variant, parsed_transcripts):
         variant(cyvcf2.Variant)
         parsed_transcripts(list)
     """
-    # XXX: Why is clnsig_predictions set to emtpy list and then compared?
-    clnsig_predictions = []
-    if len(clnsig_predictions) == 0 and len(parsed_transcripts) > 0:
-        # Parse INFO fielf to collect clnsig info
-        clnsig_predictions = parse_clnsig(variant, transcripts=parsed_transcripts)
-
+    clnsig_predictions = parse_clnsig(variant, transcripts=parsed_transcripts)
     parsed_variant["clnsig"] = clnsig_predictions
 
+    clnsig_onco_predictions = parse_clnsig_onc(variant)
+    if clnsig_onco_predictions:
+        parsed_variant["clnsig_onc"] = clnsig_onco_predictions
+
 
 def set_rank_result(parsed_variant, variant, rank_results_header):
     """Set rank_result in parsed_variant

scout/server/app.py

@@ -29,6 +29,7 @@ from .blueprints import (
     institutes,
     login,
     managed_variants,
+    mme,
     omics_variants,
     panels,
     phenomodels,
@@ -116,6 +117,10 @@ def configure_extensions(app):
         extensions.chanjo_report.init_app(app)
         LOG.info("Chanjo extension enabled")
 
+    if app.config.get("CHANJO2_URL"):
+        LOG.info("Chanjo2 extension enabled")
+        extensions.chanjo2.init_app(app)
+
     if app.config.get("LOQUSDB_SETTINGS"):
         LOG.info("LoqusDB enabled")
         # setup LoqusDB
@@ -149,15 +154,7 @@ def configure_extensions(app):
         # setup rerunner service
         extensions.rerunner.init_app(app)
 
-    if app.config.get("LDAP_HOST"):
-        LOG.info("LDAP login enabled")
-        # setup connection to server
-        extensions.ldap_manager.init_app(app)
-
-    if app.config.get("GOOGLE"):
-        LOG.info("Google login enabled")
-        # setup connection to google oauth2
-        configure_oauth_login(app)
+    set_login_system(app)
 
     if app.config.get("CUSTOM_IGV_TRACKS") or app.config.get("CLOUD_IGV_TRACKS"):
         LOG.info("Collecting IGV tracks from cloud or local resources")
@@ -172,12 +169,28 @@ def configure_extensions(app):
         extensions.bionano_access.init_app(app)
 
 
+def set_login_system(app):
+    """Initialize login system: LDAP, Google OAuth, Keycloak. If none of these is set, then simple database user matching is used."""
+    if app.config.get("LDAP_HOST"):
+        LOG.info("LDAP login enabled")
+        extensions.ldap_manager.init_app(app)
+
+    if app.config.get("GOOGLE"):
+        LOG.info("Google login enabled")
+        configure_google_login(app)
+
+    if app.config.get("KEYCLOAK"):
+        LOG.info("keycloak login enabled")
+        configure_keycloak_login(app)
+
+
 def register_blueprints(app):
     """Register Flask blueprints."""
     app.register_blueprint(public.public_bp)
     app.register_blueprint(genes.genes_bp)
     app.register_blueprint(cases.cases_bp)
     app.register_blueprint(clinvar.clinvar_bp)
+    app.register_blueprint(mme.mme_bp)
     app.register_blueprint(login.login_bp)
     app.register_blueprint(variant.variant_bp)
     app.register_blueprint(variants.variants_bp)
@@ -301,25 +314,29 @@ def register_tests(app):
         return os.path.exists(path)
 
 
-def configure_oauth_login(app):
-    """Register the Google Oauth login client using config settings"""
-
-    google_conf = app.config["GOOGLE"]
-    discovery_url = google_conf.get("discovery_url")
-    client_id = google_conf.get("client_id")
-    client_secret = google_conf.get("client_secret")
-
+def configure_oidc_login(app: Flask, provider_name: str, config_key: str):
+    """Register an OIDC login client using config settings."""
+    provider_conf = app.config[config_key]
     extensions.oauth_client.init_app(app)
-
     extensions.oauth_client.register(
-        name="google",
-        server_metadata_url=discovery_url,
-        client_id=client_id,
-        client_secret=client_secret,
+        name=provider_name,
+        server_metadata_url=provider_conf.get("discovery_url"),
+        client_id=provider_conf.get("client_id"),
+        client_secret=provider_conf.get("client_secret"),
         client_kwargs={"scope": "openid email profile"},
     )
 
 
+def configure_google_login(app):
+    """Register the Google Oauth login client using config settings"""
+    configure_oidc_login(app, "google", "GOOGLE")
+
+
+def configure_keycloak_login(app):
+    """Register a Keycloak OIDC login client using config settings"""
+    configure_oidc_login(app, "keycloak", "KEYCLOAK")
+
+
 def configure_email_logging(app):
     """Setup logging of error/exceptions to email."""
     import logging

scout/server/blueprints/alignviewers/controllers.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 import logging
 import os.path
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 
 from flask import flash, session
 from flask_login import current_user
@@ -43,7 +43,9 @@ def set_session_tracks(display_obj: dict):
 
     session_tracks = list(display_obj.get("reference_track", {}).values())
     for key, track_items in display_obj.items():
-        if key not in ["tracks", "custom_tracks", "sample_tracks", "config_custom_tracks"]:
+        if key not in ["tracks", "custom_tracks", "sample_tracks", "config_custom_tracks"] + list(
+            CASE_SPECIFIC_TRACKS.keys()
+        ):
             continue
         for track_item in track_items:
             session_tracks += list(track_item.values())
@@ -263,11 +265,25 @@ def make_locus_from_gene(variant_obj: Dict, case_obj: Dict, build: str) -> str:
     return f"{chrom}:{locus_start}-{locus_end}"
 
 
-def set_tracks(name, file_list):
-    """Return a dict according to IGV track format."""
+def get_tracks(name_list: list, file_list: list) -> List[Dict]:
+    """Return a list of dict according to IGV track format.
+
+    If an index can be found (e.g. for bam, cram files), use it explicitly.
+    If the format is one of those two alignment types, set it explicitly: it will need to be dynamically
+    filled into the igv_viewer html template script for igv.js.
+    """
     track_list = []
-    for track in file_list:
-        track_list.append({"name": name, "url": track, "min": 0.0, "max": 30.0})
+    for name, track in zip(name_list, file_list):
+        if track == "missing":
+            continue
+        track_config = {"name": name, "url": track, "min": 0.0, "max": 30.0}
+        index = find_index(track)
+        if index:
+            track_config["indexURL"] = index
+        file_format_ending = track.split(".")[-1]
+        if file_format_ending in ["bam", "cram"]:
+            track_config["format"] = file_format_ending
+        track_list.append(track_config)
     return track_list
 
 
@@ -338,17 +354,20 @@ def set_sample_tracks(display_obj: dict, case_groups: list, chromosome: str):
 
 
 def set_case_specific_tracks(display_obj, case_obj):
-    """Set up tracks from files that might be present or not at the case level
+    """Set up tracks from files that might be present for the focus case samples,
+        not fetched for all samples in the case group.
         (rhocall files, tiddit coverage files, upd regions and sites files)
     Args:
         display_obj(dict) dictionary containing all tracks info
         form(dict) flask request form dictionary
     """
     for track, label in CASE_SPECIFIC_TRACKS.items():
-        if case_obj.get(track) is None:
+        if None in [case_obj.get(track), case_obj.get("sample_names")]:
             continue
-        track_info = set_tracks(label, case_obj.get(track).split(","))
-        display_obj[track] = track_info
+
+        display_obj[track] = get_tracks(
+            [f"{label} - {sample}" for sample in case_obj.get("sample_names")], case_obj.get(track)
+        )
 
 
 def set_config_custom_tracks(display_obj: dict, build: str):

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

@@ -86,12 +86,12 @@
                           {% endif %}
                         },
                       {% endfor %}
-                      {% for wtrack in rhocall_wig %}
+                      {% for wtrack in rhocall_wigs %}
                       {
                         type: "wig",
                         name: '{{ wtrack.name }}',
                         url: '{{ url_for("alignviewers.remote_static", file=wtrack.url) }}',
-                        format: 'wig',
+                        format: 'bw',
                         {# indexURL: '{{ url_for("alignviewers.remote_static", file=wtrack.url)  }}', #}
                         color: "rgb(60, 37, 17)",
                         min: '{{ wtrack.min }}',
@@ -99,12 +99,12 @@
                         sourceType: 'file'
                       },
                       {% endfor %}
-                      {% for btrack in rhocall_bed %}
+                      {% for btrack in rhocall_beds %}
                       {
-                        type: "bed",
+                        type: "annotation",
                         name: '{{ btrack.name }}',
                         url: '{{ url_for("alignviewers.remote_static", file=btrack.url) }}',
-                        format: 'bed',
+                        format: 'bb',
                         color: "rgb(65, 31, 30)",
                         sourceType: 'file'
                       },
@@ -117,33 +117,73 @@
                         indexURL: "{{ url_for('alignviewers.remote_static', file=track.indexURL) }}",
                         sourceType: "file",
                         groupBy: "tag:HP",
-                        colorBy: "basemod2:m",
                         showSoftClips: {{track.show_soft_clips | lower }},
                         format: "{{ track.format }}",
                         height: "{{track.height}}"
                       },
                       {% endfor %}
-                      {% for ttrack in tiddit_coverage_wig %}
+                      {% for ttrack in tiddit_coverage_wigs %}
                       {
                         type: "wig",
+                        format: 'bw',
                         name: '{{ ttrack.name }}',
                         url: '{{ url_for("alignviewers.remote_static", file=ttrack.url) }}',
                         color: "rgb(40, 0, 13)",
                         sourceType: 'file'
                       },
                       {% endfor %}
-                      {% for rtrack in upd_regions_bed %}
+                      {% for maftrack in minor_allele_frequency_wigs %}
                       {
-                        type: "bed",
+                        type: "wig",
+                        format: 'bw',
+                        name: '{{ maftrack.name }}',
+                        url: '{{ url_for("alignviewers.remote_static", file=maftrack.url) }}',
+                        color: "rgb(60, 60, 140)",
+                        sourceType: 'file'
+                      },
+                      {% endfor %}
+                      {% for ptrack in paraphase_alignments %}
+                      {
+                        type: "alignment",
+                        name: "{{ ptrack.name }}",
+                        url: '{{ url_for("alignviewers.remote_static", file=ptrack.url) }}',
+                        format: "{{ ptrack.format }}",
+                        groupBy: "tag:HP",
+                        indexURL: '{{ url_for("alignviewers.remote_static", file=ptrack.indexURL)  }}',
+                        min: '{{ ptrack.min }}',
+                        max: '{{ ptrack.max }}',
+                        sourceType: 'file'
+                      },
+                      {% endfor %}
+                      {% for atrack in assembly_alignments %}
+                      {
+                        type: "alignment",
+                        name: "{{ atrack.name }}",
+                        url: '{{ url_for("alignviewers.remote_static", file=atrack.url) }}',
+                        format: "{{ atrack.format }}",
+                        groupBy: "tag:HP",
+                        height: 140,
+                        showCoverage: false,
+                        indexURL: '{{ url_for("alignviewers.remote_static", file=atrack.indexURL)  }}',
+                        min: '{{ atrack.min }}',
+                        max: '{{ atrack.max }}',
+                        sourceType: 'file'
+                      },
+                      {% endfor %}
+                      {% for rtrack in upd_regions_beds %}
+                      {
+                        type: 'annotation',
+                        format: 'bb',
                         name: '{{ rtrack.name }}',
                         url: '{{ url_for("alignviewers.remote_static", file=rtrack.url) }}',
                         color: "rgb(0, 204, 102)",
                         sourceType: 'file'
                       },
                       {% endfor %}
-                      {% for strack in upd_sites_bed %}
+                      {% for strack in upd_sites_beds %}
                       {
-                        type: "bed",
+                        type: "annotation",
+                        format: 'bb',
                         name: '{{ strack.name }}',
                         url: '{{ url_for("alignviewers.remote_static", file=strack.url) }}',
                         color: "rgb(25, 61, 4)",

scout/server/blueprints/cases/controllers.py

@@ -40,7 +40,12 @@ from scout.constants.variant_tags import (
     MANUAL_RANK_OPTIONS,
 )
 from scout.export.variant import export_mt_variants
-from scout.parse.matchmaker import genomic_features, hpo_terms, omim_terms, parse_matches
+from scout.parse.matchmaker import (
+    genomic_features,
+    hpo_terms,
+    omim_terms,
+    parse_matches,
+)
 from scout.server.blueprints.variant.controllers import variant as variant_decorator
 from scout.server.blueprints.variants.controllers import get_manual_assessments
 from scout.server.extensions import (
@@ -61,6 +66,7 @@ from scout.server.utils import (
     case_has_mt_alignments,
     case_has_mtdna_report,
     case_has_rna_tracks,
+    get_case_mito_chromosome,
     institute_and_case,
 )
 from scout.utils.acmg import get_acmg_temperature
@@ -788,11 +794,11 @@ def mt_excel_files(store, case_obj, temp_excel_dir):
 
     # Check if coverage and MT copy number stats are available via chanjo2 or chanjo
     if case_obj.get("chanjo2_coverage"):
-        coverage_stats: Dict[str, dict] = chanjo2.mt_coverage_stats(individuals=samples)
+        coverage_stats: Dict[str, dict] = chanjo2.mt_coverage_stats(case_obj=case_obj)
     elif case_obj.get("chanjo_coverage"):
         coverage_stats: Dict[str, dict] = chanjo_report.mt_coverage_stats(individuals=samples)
 
-    query = {"chrom": "MT"}
+    query = {"chrom": get_case_mito_chromosome(case_obj)}
     mt_variants = list(
         store.variants(case_id=case_obj["_id"], query=query, nr_of_variants=-1, sort_key="position")
     )