scout-browser 4.85__py3-none-any.whl → 4.86__py3-none-any.whl

scout/__version__.py

@@ -1 +1 @@
-__version__ = "4.85"
+__version__ = "4.86"

scout/adapter/mongo/base.py

@@ -45,6 +45,7 @@ from .index import IndexHandler
 from .institute import InstituteHandler
 from .managed_variant import ManagedVariantHandler
 from .matchmaker import MMEHandler
+from .omics_variant import OmicsVariantHandler
 from .panel import PanelHandler
 from .phenomodel import PhenoModelHandler
 from .query import QueryHandler
@@ -57,27 +58,28 @@ LOG = logging.getLogger(__name__)
 
 
 class MongoAdapter(
-    GeneHandler,
-    CaseHandler,
+    ACMGHandler,
     CaseGroupHandler,
-    InstituteHandler,
+    CaseHandler,
+    ClinVarHandler,
+    CytobandHandler,
+    DiagnosisHandler,
     EventHandler,
+    FilterHandler,
+    GeneHandler,
     HpoHandler,
-    DiagnosisHandler,
-    PanelHandler,
-    QueryHandler,
-    VariantHandler,
-    UserHandler,
-    ACMGHandler,
     IndexHandler,
-    ClinVarHandler,
+    InstituteHandler,
     MMEHandler,
-    TranscriptHandler,
-    FilterHandler,
     ManagedVariantHandler,
-    CytobandHandler,
+    OmicsVariantHandler,
+    PanelHandler,
     PhenoModelHandler,
+    QueryHandler,
     RankModelHandler,
+    TranscriptHandler,
+    UserHandler,
+    VariantHandler,
 ):
     """Adapter for communication with a Mongo database."""
 
@@ -108,9 +110,10 @@ class MongoAdapter(
         self.hpo_term_collection = database.hpo_term
         self.institute_collection = database.institute
         self.managed_variant_collection = database.managed_variant
+        self.omics_variant_collection = database.omics_variant
         self.panel_collection = database.gene_panel
-        self.rank_model_collection = database.rank_model
         self.phenomodel_collection = database.phenomodel
+        self.rank_model_collection = database.rank_model
         self.transcript_collection = database.transcript
         self.user_collection = database.user
         self.variant_collection = database.variant

scout/adapter/mongo/case.py

@@ -10,7 +10,7 @@ import pymongo
 from bson import ObjectId
 
 from scout.build.case import build_case
-from scout.constants import ACMG_MAP, FILE_TYPE_MAP, ID_PROJECTION
+from scout.constants import ACMG_MAP, FILE_TYPE_MAP, ID_PROJECTION, OMICS_FILE_TYPE_MAP
 from scout.exceptions import ConfigError, IntegrityError
 from scout.parse.variant.ids import parse_document_id
 from scout.utils.algorithms import ui_score
@@ -834,6 +834,21 @@ class CaseHandler(object):
             if key in old_case:
                 new_case[key] = old_case[key]
 
+    def _load_omics_variants(self, case_obj: dict, build: str, update: bool = False):
+        """Load omics variants. The OMICS FILE type dict contains all we need to
+        determine how to load variants (type, category etc)."""
+
+        for omics_file in OMICS_FILE_TYPE_MAP.keys():
+            if not case_obj["omics_files"].get(omics_file):
+                LOG.debug("didn't find %s for case, skipping", omics_file)
+                continue
+
+            if update:
+                LOG.debug("deleting %s omics variants for case", omics_file)
+                self.delete_omics_variants(case_id=case_obj["_id"], file_type=omics_file)
+
+            self.load_omics_variants(case_obj=case_obj, build=build, file_type=omics_file)
+
     def load_case(self, config_data: dict, update: bool = False, keep_actions: bool = True) -> dict:
         """Load a case into the database
 
@@ -930,6 +945,8 @@ class CaseHandler(object):
         except (IntegrityError, ValueError, ConfigError, KeyError) as error:
             LOG.warning(error)
 
+        self._load_omics_variants(case_obj, build=genome_build, update=update)
+
         if existing_case:
             self.update_case_data_sharing(old_case=existing_case, new_case=case_obj)
             case_obj["rerun_requested"] = False
@@ -1049,6 +1066,7 @@ class CaseHandler(object):
                 "gene_fusion_report_research": case_obj.get("gene_fusion_report_research"),
                 "genome_build": case_obj.get("genome_build", "37"),
                 "has_meivariants": case_obj.get("has_meivariants"),
+                "has_outliers": case_obj.get("has_outliers"),
                 "has_strvariants": case_obj.get("has_strvariants"),
                 "has_svvariants": case_obj.get("has_svvariants"),
                 "individuals": case_obj["individuals"],
@@ -1057,6 +1075,7 @@ class CaseHandler(object):
                 "mme_submission": case_obj.get("mme_submission"),
                 "multiqc": case_obj.get("multiqc"),
                 "multiqc_rna": case_obj.get("multiqc_rna"),
+                "omics_files": case_obj.get("omics_files"),
                 "panels": case_obj.get("panels", []),
                 "phenotype_groups": case_obj.get("phenotype_groups"),
                 "phenotype_terms": case_obj.get("phenotype_terms"),

scout/adapter/mongo/filter.py

@@ -1,8 +1,9 @@
 # -*- coding: utf-8 -*-
 import logging
+from typing import Optional
 
 from bson.objectid import ObjectId
-from flask import url_for
+from flask import flash, url_for
 from pymongo.cursor import CursorType
 from werkzeug.datastructures import MultiDict
 
@@ -105,6 +106,40 @@ class FilterHandler(object):
 
         return filter_id
 
+    def unaudit_filter(self, audit_id: ObjectId, user_obj: dict):
+        """Removes an audit filter event with a new un-audit filter event."""
+
+        FILTER_SEARCH = {"_id": ObjectId(audit_id), "verb": "filter_audit"}
+
+        audit_event: Optional[dict] = self.event_collection.find_one(FILTER_SEARCH)
+        if audit_event is None:
+            return
+        if audit_event.get("user_id") != user_obj["email"]:
+            flash("You can't un-audit a filter audited by another user.", "warning")
+            return
+        institute_obj: Optional[dict] = self.institute(institute_id=audit_event.get("institute"))
+        case_obj: Optional[dict] = self.case(case_id=audit_event.get("case"))
+        if None in [institute_obj, case_obj]:
+            LOG.error(
+                f"An error occurred un-auditing filter: institute or case missing for audit event {audit_id}."
+            )
+            return
+
+        # Create un-audit event
+        self.create_event(
+            institute=institute_obj,
+            case=case_obj,
+            user=user_obj,
+            link=audit_event["link"],
+            category="case",
+            verb="filter_unaudit",
+            subject=audit_event["subject"],
+            level="global",
+        )
+
+        # Remove audit event
+        self.event_collection.delete_one(FILTER_SEARCH)
+
     def audit_filter(self, filter_id, institute_obj, case_obj, user_obj, category="snv", link=None):
         """Mark audit of filter for case in events.
         Audit filter leaves a voluntary log trail to answer questions like "did I really check for recessive variants"

scout/adapter/mongo/omics_variant.py

@@ -0,0 +1,145 @@
+import logging
+from typing import Dict, Optional
+
+from scout.constants import OMICS_FILE_TYPE_MAP
+from scout.models.omics_variant import OmicsVariantLoader
+from scout.parse.omics_variant import parse_omics_file
+
+LOG = logging.getLogger(__name__)
+
+
+class OmicsVariantHandler:
+    def delete_omics_variants(self, case_id: str, file_type: str):
+        """Delete OMICS variants for a case"""
+        omics_file_type = OMICS_FILE_TYPE_MAP.get(file_type)
+        category = omics_file_type["category"]
+        sub_category = omics_file_type["sub_category"]
+        variant_type = omics_file_type["variant_type"]
+
+        LOG.info(
+            "Deleting old %s %s %s OMICS variants.",
+            variant_type,
+            sub_category,
+            category,
+        )
+
+        query = {
+            "case_id": case_id,
+            "variant_type": variant_type,
+            "category": category,
+            "sub_category": sub_category,
+        }
+        result = self.omics_variant_collection.delete_many(query)
+
+        LOG.info("%s variants deleted", result.deleted_count)
+
+    def set_samples(self, case_obj: dict, omics_model: dict):
+        """Internal member function to connect individuals.
+        OMICS variants do not have a genotype as such."""
+
+        samples = []
+
+        for ind in case_obj.get("individuals"):
+            if omics_model["sampleID"] == ind.get("individual_id"):
+                sample = {
+                    "sample_id": ind["individual_id"],
+                    "display_name": ind["display_name"],
+                    "genotype_call": "./1",
+                }
+                samples.append(sample)
+
+        omics_model["samples"] = samples
+
+    def set_genes(self, omics_model: dict):
+        """Internal member function to connect gene based on the hgnc_id / symbol / geneID given in outlier file.
+        We start with the case of having one hgnc_id.
+        """
+        hgnc_gene = self.hgnc_gene(omics_model["hgnc_ids"][0], omics_model["build"])
+        if hgnc_gene:
+            omics_model["genes"] = [hgnc_gene]
+
+    def load_omics_variants(self, case_obj: dict, file_type: str, build: Optional[str] = "37"):
+        """Load OMICS variants for a case"""
+
+        case_panels = case_obj.get("panels", [])
+        gene_to_panels = self.gene_to_panels(case_obj)
+
+        omics_file_type: dict = OMICS_FILE_TYPE_MAP.get(file_type)
+
+        nr_inserted = 0
+
+        file_handle = open(case_obj["omics_files"].get(file_type), "r")
+
+        for omics_info in parse_omics_file(file_handle, omics_file_type=omics_file_type):
+            omics_info["case_id"] = case_obj["_id"]
+            omics_info["build"] = "37" if "37" in build else "38"
+            omics_info["file_type"] = file_type
+            omics_info["institute"] = case_obj["owner"]
+            for key in ["category", "sub_category", "variant_type", "analysis_type"]:
+                omics_info[key] = omics_file_type[key]
+
+            omics_model = OmicsVariantLoader(**omics_info).model_dump(
+                by_alias=True, exclude_none=True
+            )
+
+            self.set_genes(omics_model)
+            self.set_samples(case_obj, omics_model)
+
+            # If case has gene panels, only add clinical variants with a matching gene
+            variant_genes = [gene["hgnc_id"] for gene in omics_model.get("genes", [])]
+            if (
+                omics_model["variant_type"] == "clinical"
+                and case_panels
+                and all(variant_gene not in gene_to_panels for variant_gene in variant_genes)
+            ):
+                continue
+
+            self.omics_variant_collection.insert_one(omics_model)
+            nr_inserted += 1
+
+        LOG.info("%s variants inserted", nr_inserted)
+
+    def omics_variant(self, variant_id: str, projection: Optional[Dict] = None):
+        """Return omics variant"""
+
+        return self.omics_variant_collection.find_one({"omics_variant_id": variant_id}, projection)
+
+    def omics_variants(
+        self,
+        case_id: str,
+        query=None,
+        category: str = "outlier",
+        nr_of_variants=50,
+        skip=0,
+        projection: Optional[Dict] = None,
+        build="37",
+    ):
+        """Return omics variants for a case, of a particular type (clinical, research) and category (outlier, ...)."""
+
+        if nr_of_variants == -1:
+            nr_of_variants = 0  # This will return all variants
+        else:
+            nr_of_variants = skip + nr_of_variants
+
+        query = self.build_query(case_id, query=query, category=category, build=build)
+        return self.omics_variant_collection.find(
+            query, projection, skip=skip, limit=nr_of_variants
+        )
+
+    def count_omics_variants(
+        self, case_id, query, variant_ids=None, category="outlier", build="37"
+    ):
+        """Returns number of variants
+
+        Arguments:
+            case_id(str): A string that represents the case
+            query(dict): A query dictionary
+
+        Returns:
+             integer
+        """
+
+        query = self.build_query(
+            case_id, query=query, variant_ids=variant_ids, category=category, build=build
+        )
+        return self.omics_variant_collection.count_documents(query)

scout/adapter/mongo/query.py

@@ -1,6 +1,7 @@
 import logging
 import re
 from datetime import datetime, timedelta
+from typing import Optional, Union
 
 from scout.constants import (
     CLINSIG_MAP,
@@ -76,7 +77,11 @@ class QueryHandler(object):
         return variants_query
 
     def build_variant_query(
-        self, query=None, institute_ids=[], category="snv", variant_type=["clinical"]
+        self,
+        query: Optional[dict] = None,
+        institute_ids: Optional[list] = [],
+        category: Optional[Union[str, list]] = "snv",
+        variant_type: Optional[list] = ["clinical"],
     ):
         """Build a mongo query across multiple cases.
         Translate query options from a form into a complete mongo query dictionary.
@@ -93,7 +98,7 @@ class QueryHandler(object):
         Args:
             query(dict): A query dictionary for the database, from a query form.
             institute_ids: a list of institute _ids
-            category(str): 'snv', 'sv', 'str' 'cancer_sv' or 'cancer'
+            category(str): 'snv', 'sv', 'str' 'cancer_sv' or 'cancer' OR a LIST(str) of the same
             variant_type(str): 'clinical' or 'research'
 
         Possible query dict keys:
@@ -112,7 +117,12 @@ class QueryHandler(object):
 
         mongo_variant_query["hgnc_symbols"] = {"$in": query["hgnc_symbols"]}
         mongo_variant_query["variant_type"] = {"$in": variant_type}
-        mongo_variant_query["category"] = category
+
+        if not category:
+            category = "snv"
+        mongo_variant_query["category"] = (
+            {"$in": category} if isinstance(category, list) else category
+        )
 
         select_cases = None
         select_case_obj = None

scout/adapter/mongo/variant.py

@@ -206,7 +206,7 @@ class VariantHandler(VariantLoader):
 
         return result
 
-    def count_variants(self, case_id, query, variant_ids, category):
+    def count_variants(self, case_id, query, variant_ids, category, build="37"):
         """Returns number of variants
 
         Arguments:
@@ -219,7 +219,9 @@ class VariantHandler(VariantLoader):
              integer
         """
 
-        query = self.build_query(case_id, query=query, variant_ids=variant_ids, category=category)
+        query = self.build_query(
+            case_id, query=query, variant_ids=variant_ids, category=category, build=build
+        )
         return self.variant_collection.count_documents(query)
 
     def variant_update_field(self, variant_id: str, field_name: str, field_value: Any) -> dict:
@@ -237,6 +239,7 @@ class VariantHandler(VariantLoader):
         case_id=None,
         simple_id=None,
         variant_type="clinical",
+        projection=None,
     ):
         """Returns the specified variant.
 
@@ -264,7 +267,7 @@ class VariantHandler(VariantLoader):
             # search with a unique id
             query["_id"] = document_id
 
-        variant_obj = self.variant_collection.find_one(query)
+        variant_obj = self.variant_collection.find_one(query, projection=projection)
         if not variant_obj:
             return variant_obj
         case_obj = self.case(
@@ -890,7 +893,10 @@ class VariantHandler(VariantLoader):
             }
         }
         pipeline = [match, group]
-        results = self.variant_collection.aggregate(pipeline)
+        results = list(self.variant_collection.aggregate(pipeline))
+
+        omics_results = list(self.omics_variant_collection.aggregate(pipeline))
+        results.extend(omics_results)
 
         variants_by_type = {}
         for item in results:

scout/build/case.py

@@ -285,6 +285,7 @@ def build_case(case_data, adapter):
             case_obj[report_key] = case_data.get(report_key)
 
     case_obj["vcf_files"] = case_data.get("vcf_files", {})
+    case_obj["omics_files"] = case_data.get("omics_files", {})
     case_obj["delivery_report"] = case_data.get("delivery_report")
 
     _populate_pipeline_info(case_obj, case_data)
@@ -297,6 +298,10 @@ def build_case(case_data, adapter):
 
     case_obj["has_meivariants"] = bool(case_obj["vcf_files"].get("vcf_mei"))
 
+    case_obj["has_outliers"] = bool(
+        case_obj["omics_files"].get("fraser") or case_obj["omics_files"].get("outrider")
+    )
+
     case_obj["is_migrated"] = False
 
     # What experiment is used, alternatives are rare (rare disease) or cancer

scout/build/variant/variant.py

@@ -460,6 +460,7 @@ def add_frequencies(variant_obj, frequencies):
     variant_obj["thousand_genomes_frequency_right"] = call_safe(
         float, frequencies.get("thousand_g_right")
     )
+    variant_obj["colorsdb_af"] = call_safe(float, frequencies.get("colorsdb_af"))
 
     # Add the sv counts:
     variant_obj["clingen_cgh_benign"] = frequencies.get("clingen_benign")

scout/constants/__init__.py

@@ -45,11 +45,12 @@ from .disease_parsing import (
     MIMNR_PATTERN,
     OMIM_STATUS_MAP,
 )
-from .file_types import FILE_TYPE_MAP
+from .file_types import FILE_TYPE_MAP, OMICS_FILE_TYPE_MAP
 from .filters import (
     CLINICAL_FILTER_BASE,
     CLINICAL_FILTER_BASE_CANCER,
     CLINICAL_FILTER_BASE_MEI,
+    CLINICAL_FILTER_BASE_OUTLIER,
     CLINICAL_FILTER_BASE_SV,
 )
 from .gene_tags import (
@@ -88,6 +89,7 @@ from .variant_tags import (
     GENETIC_MODELS_PALETTE,
     MANUAL_RANK_OPTIONS,
     MOSAICISM_OPTIONS,
+    OUTLIER_TYPES,
     SPIDEX_HUMAN,
     SPIDEX_LEVELS,
     SV_TYPES,

scout/constants/case_tags.py

@@ -117,6 +117,7 @@ VERBS_MAP = {
     "dismiss_variant": "dismissed variant for",
     "filter_audit": "marked case audited with filter",
     "filter_stash": "stored a filter for",
+    "filter_unaudit": "un-audited a filter for",
     "manual_rank": "updated manual rank for",
     "mark_causative": "marked causative for",
     "mark_partial_causative": "mark partial causative for",

scout/constants/clinvar.py

@@ -1,4 +1,4 @@
-CLINVAR_API_URL = "https://submit.ncbi.nlm.nih.gov/api/v1/submissions/"
+CLINVAR_API_URL_DEFAULT = "https://submit.ncbi.nlm.nih.gov/api/v1/submissions/"
 PRECLINVAR_URL = "https://preclinvar.scilifelab.se"
 
 ASSERTION_METHOD = "ACMG Guidelines, 2015"

scout/constants/file_types.py

@@ -88,3 +88,34 @@ FILE_TYPE_MAP = {
         "load_priority": 50,
     },
 }
+
+OMICS_FILE_TYPE_MAP = {
+    "fraser": {
+        "format": "tsv",
+        "analysis_type": "wts",
+        "category": "outlier",
+        "sub_category": "splicing",
+        "variant_type": "clinical",
+    },
+    "outrider": {
+        "format": "tsv",
+        "analysis_type": "wts",
+        "category": "outlier",
+        "sub_category": "expression",
+        "variant_type": "clinical",
+    },
+    "fraser_research": {
+        "format": "tsv",
+        "analysis_type": "wts",
+        "category": "outlier",
+        "sub_category": "splicing",
+        "variant_type": "research",
+    },
+    "outrider_research": {
+        "format": "tsv",
+        "analysis_type": "wts",
+        "category": "outlier",
+        "sub_category": "expression",
+        "variant_type": "research",
+    },
+}

scout/constants/filters.py

@@ -30,3 +30,7 @@ CLINICAL_FILTER_BASE_MEI = {
     "functional_annotations": SEVERE_SO_TERMS_SV,
     "swegen_freq": "0.02",
 }
+
+CLINICAL_FILTER_BASE_OUTLIER = {
+    "variant_type": "clinical",
+}

scout/constants/indexes.py

@@ -12,23 +12,48 @@ INDEXES = {
         IndexModel(
             [("build", ASCENDING), ("chromosome", ASCENDING)],
             name="build_chromosome",
-            background=True,
         ),
         IndexModel(
             [("build", ASCENDING), ("hgnc_id", ASCENDING)],
             name="build_hgncid",
-            background=True,
         ),
         IndexModel(
             [("build", ASCENDING), ("aliases", ASCENDING)],
             name="build_aliases",
-            background=True,
         ),
         IndexModel(
             [("build", ASCENDING), ("hgnc_symbol", ASCENDING)],
             name="build_hgnc_symbol",
         ),
     ],
+    "omics_variant": [
+        IndexModel(
+            # Clear text variant id index
+            [
+                ("omics_variant_id", ASCENDING),
+            ],
+            name="omics_variant_id",
+        ),
+        IndexModel(
+            # Index for searching across cases for a change in given genes
+            [
+                ("hgnc_ids", ASCENDING),
+                ("sub_category", ASCENDING),
+                ("variant_type", ASCENDING),
+            ],
+            name="hgnc_ids_sub_category_variant_type",
+        ),
+        IndexModel(
+            # Filterish index
+            [
+                ("case_id", ASCENDING),
+                ("variant_type", ASCENDING),
+                ("sub_category", ASCENDING),
+                ("hgnc_ids", ASCENDING),
+            ],
+            name="case_id_variant_type_sub_category_hgnc_ids",
+        ),
+    ],
     "variant": [
         IndexModel(
             [
@@ -39,7 +64,6 @@ INDEXES = {
                 ("hgnc_ids", ASCENDING),
             ],
             name="caseid_category_varianttype_variantrank_hgncids",
-            background=True,
         ),
         IndexModel(
             [
@@ -49,8 +73,7 @@ INDEXES = {
                 ("variant_type", ASCENDING),
             ],
             name="hgncsymbol_rankscore_category_varianttype",
-            background=True,
-            partialFilterExpression={"rank_score": {"$gt": 5}, "category": "snv"},
+            partialFilterExpression={"rank_score": {"$gte": 5}},
         ),
         IndexModel(
             [
@@ -59,7 +82,6 @@ INDEXES = {
                 ("category", ASCENDING),
             ],
             name="variantid_caseid_category",
-            background=True,
         ),
         IndexModel(
             [
@@ -69,7 +91,6 @@ INDEXES = {
                 ("rank_score", ASCENDING),
             ],
             name="category_caseid_varianttype_rankscore",
-            background=True,
         ),
         IndexModel(
             [
@@ -81,18 +102,16 @@ INDEXES = {
                 ("end", ASCENDING),
             ],
             name="caseid_category_chromosome_start_end",
-            background=True,
         ),
         IndexModel(
             [("variant_id", ASCENDING), ("institute", ASCENDING)],
             name="variant_id_institute",
-            background=True,
         ),
     ],
     "hpo_term": [
         IndexModel([("description", ASCENDING)], name="description"),
         IndexModel([("description", TEXT)], default_language="english", name="description_text"),
-        IndexModel([("hpo_number", ASCENDING)], name="number", background=True),
+        IndexModel([("hpo_number", ASCENDING)], name="number"),
     ],
     "event": [
         IndexModel(
@@ -115,14 +134,12 @@ INDEXES = {
         IndexModel(
             [("build", ASCENDING), ("hgnc_id", ASCENDING), ("length", DESCENDING)],
             name="hgncid_length",
-            background=True,
         )
     ],
     "exon": [
         IndexModel(
             [("build", ASCENDING), ("hgnc_id", ASCENDING)],
             name="build_hgncid",
-            background=True,
         )
     ],
     "case": [

scout/constants/variant_tags.py

@@ -37,6 +37,8 @@ FEATURE_TYPES = (
 
 SV_TYPES = ("ins", "del", "dup", "cnv", "inv", "bnd")
 
+OUTLIER_TYPES = ("splicing", "expression")
+
 GENETIC_MODELS = (
     ("AR_hom", "Autosomal Recessive Homozygote"),
     ("AR_hom_dn", "Autosomal Recessive Homozygote De Novo"),
@@ -519,4 +521,5 @@ VARIANTS_TARGET_FROM_CATEGORY = {
     "snv": "variants.variants",
     "str": "variants.str_variants",
     "fusion": "variants.fusion_variants",
+    "outlier": "omics_variants.outliers",
 }

scout/demo/643594.config.yaml

@@ -125,6 +125,10 @@ vcf_snv_research: scout/demo/643594.research.vcf.gz
 vcf_sv_research: scout/demo/643594.research.SV.vcf.gz
 vcf_mei_research: scout/demo/643594.research.mei.vcf.gz
 
+omics_files:
+    fraser: scout/demo/drop/fraser_top_hits_clinical.tsv
+    outrider: scout/demo/drop/outrider_top_hits_clinical.tsv
+
 smn_tsv: scout/demo/643594.solo.smn.tsv
 
 madeline: scout/demo/madeline.xml