scout-browser 4.95.0__py3-none-any.whl → 4.97.0__py3-none-any.whl

scout/adapter/mongo/case.py

@@ -3,6 +3,7 @@ import datetime
 import logging
 import operator
 import re
+from collections import OrderedDict
 from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
@@ -11,11 +12,16 @@ from bson import ObjectId
 from werkzeug.datastructures import ImmutableMultiDict
 
 from scout.build.case import build_case
-from scout.constants import ACMG_MAP, CCV_MAP, FILE_TYPE_MAP, ID_PROJECTION, OMICS_FILE_TYPE_MAP
+from scout.constants import (
+    ACMG_MAP,
+    CCV_MAP,
+    ID_PROJECTION,
+    ORDERED_FILE_TYPE_MAP,
+    ORDERED_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
-from scout.utils.sort import get_load_priority
 
 LOG = logging.getLogger(__name__)
 EXISTS = "$exists"
@@ -886,11 +892,17 @@ 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):
+    def _load_clinical_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():
+        CLINICAL_ORDERED_OMICS_FILE_TYPE_MAP = OrderedDict(
+            (key, value)
+            for key, value in ORDERED_OMICS_FILE_TYPE_MAP.items()
+            if value["variant_type"] != "research"
+        )
+
+        for omics_file in CLINICAL_ORDERED_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
@@ -901,6 +913,38 @@ class CaseHandler(object):
 
             self.load_omics_variants(case_obj=case_obj, build=build, file_type=omics_file)
 
+    def _load_clinical_variants(self, case_obj: dict, build: str, update: bool = False):
+        """Load variants in the order specified by CLINICAL_ORDERED_FILE_TYPE_MAP."""
+        CLINICAL_ORDERED_FILE_TYPE_MAP = OrderedDict(
+            (key, value)
+            for key, value in ORDERED_FILE_TYPE_MAP.items()
+            if value["variant_type"] != "research"
+        )
+        load_type_cat = set()
+        for file_name, vcf_dict in CLINICAL_ORDERED_FILE_TYPE_MAP.items():
+            if not case_obj["vcf_files"].get(file_name):
+                LOG.debug("didn't find {}, skipping".format(file_name))
+                continue
+            load_type_cat.add((vcf_dict["variant_type"], vcf_dict["category"]))
+
+        for variant_type, category in load_type_cat:
+            if update:
+                self.delete_variants(
+                    case_id=case_obj["_id"],
+                    variant_type=variant_type,
+                    category=category,
+                )
+            self.load_variants(
+                case_obj=case_obj,
+                variant_type=variant_type,
+                category=category,
+                build=build,
+                rank_threshold=case_obj.get("rank_score_threshold", 5),
+                custom_images=self._get_variants_custom_images(
+                    variant_category=category, case=case_obj
+                ),
+            )
+
     def load_case(self, config_data: dict, update: bool = False, keep_actions: bool = True) -> dict:
         """Load a case into the database
 
@@ -950,77 +994,36 @@ class CaseHandler(object):
             old_evaluated_variants = list(
                 self.evaluated_variants(case_obj["_id"], case_obj["owner"])
             )
-
-        # load from files
-        files = [
-            {
-                "file_name": file_type,
-                "variant_type": FILE_TYPE_MAP[file_type]["variant_type"],
-                "category": FILE_TYPE_MAP[file_type]["category"],
-            }
-            for file_type in FILE_TYPE_MAP.keys()
-            if FILE_TYPE_MAP[file_type]["variant_type"] != "research"
-        ]
-
-        # (type, category) tuples are not unique - eg SNV, SNV_MT
-        load_variants = set()
         try:
-            for vcf_file in files:
-                # Check if any file of this kind is configured for case
-                if not case_obj["vcf_files"].get(vcf_file["file_name"]):
-                    LOG.debug("didn't find {}, skipping".format(vcf_file["file_name"]))
-                    continue
-                load_variants.add((vcf_file["variant_type"], vcf_file["category"]))
-
-            for variant_type, category in sorted(
-                load_variants,
-                key=lambda tup: get_load_priority(variant_type=tup[0], category=tup[1]),
-            ):
-                if update:
-                    self.delete_variants(
-                        case_id=case_obj["_id"],
-                        variant_type=variant_type,
-                        category=category,
-                    )
-                # add variants
-                self.load_variants(
-                    case_obj=case_obj,
-                    variant_type=variant_type,
-                    category=category,
-                    build=genome_build,
-                    rank_threshold=case_obj.get("rank_score_threshold", 5),
-                    custom_images=self._get_variants_custom_images(
-                        variant_category=category, case=case_obj
-                    ),
-                )
+            self._load_clinical_variants(case_obj, build=genome_build, update=update)
+            self._load_clinical_omics_variants(case_obj, build=genome_build, update=update)
 
         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
-            if case_obj["status"] in ["active", "archived"]:
-                case_obj["status"] = "inactive"
-
-            case_obj["variants_stats"] = self.case_variants_count(
-                case_id=case_obj["_id"],
-                institute_id=institute_obj["_id"],
-                force_update_case=True,
-            )
-
-            self.update_case_cli(case_obj, institute_obj)
-            # update Sanger status for the new inserted variants
-            self.update_case_sanger_variants(institute_obj, case_obj, old_sanger_variants)
+            LOG.exception(error)
+            raise error
+        else:
+            if not existing_case:
+                LOG.info("Loading case %s into database", case_obj["display_name"])
+                self.add_case(case_obj, institute_obj)
+        finally:
+            if existing_case:
+                self.update_case_data_sharing(old_case=existing_case, new_case=case_obj)
+                case_obj["rerun_requested"] = False
+                if case_obj["status"] in ["active", "archived"]:
+                    case_obj["status"] = "inactive"
+
+                case_obj["variants_stats"] = self.case_variants_count(
+                    case_id=case_obj["_id"],
+                    institute_id=institute_obj["_id"],
+                    force_update_case=True,
+                )
 
-            if keep_actions and old_evaluated_variants:
-                self.update_variant_actions(institute_obj, case_obj, old_evaluated_variants)
+                self.update_case_cli(case_obj, institute_obj)
+                # update Sanger status for the new inserted variants
+                self.update_case_sanger_variants(institute_obj, case_obj, old_sanger_variants)
 
-        else:
-            LOG.info("Loading case %s into database", case_obj["display_name"])
-            self.add_case(case_obj, institute_obj)
+                if keep_actions and old_evaluated_variants:
+                    self.update_variant_actions(institute_obj, case_obj, old_evaluated_variants)
 
         return case_obj
 
@@ -1087,6 +1090,7 @@ class CaseHandler(object):
             Returns:
                 updated_case(dict): The updated case information
         """
+
         LOG.info("Updating case {0}".format(case_obj["_id"]))
         old_case = self.case_collection.find_one({"_id": case_obj["_id"]})
 
@@ -1146,6 +1150,7 @@ class CaseHandler(object):
                 "RNAfusion_report": case_obj.get("RNAfusion_report"),
                 "RNAfusion_report_research": case_obj.get("RNAfusion_report_research"),
                 "rna_delivery_report": case_obj.get("rna_delivery_report"),
+                "scout_load_version": case_obj.get("scout_load_version"),
                 "smn_tsv": case_obj.get("smn_tsv"),
                 "status": case_obj.get("status"),
                 "sv_rank_model_version": case_obj.get("sv_rank_model_version"),

scout/adapter/mongo/filter.py

@@ -24,10 +24,10 @@ class FilterHandler(object):
         Returns:
             filter_obj(dict)
         """
-        filter_obj = None
-        LOG.debug("Retrieve filter {}".format(filter_id))
         filter_obj = self.filter_collection.find_one({"_id": ObjectId(filter_id)})
+
         if filter_obj is not None:
+            self.set_legacy_options(filter_obj)
             # use _id to preselect the currently loaded filter, and drop it while we are at it
             filter_obj.update([("filters", filter_obj.pop("_id", None))])
         return filter_obj
@@ -49,15 +49,6 @@ class FilterHandler(object):
         Returns:
             filter_id(str) - a unique id that can be cast to ObjectId
         """
-
-        LOG.info(
-            "Stashing filter for user '%s' and institute %s.",
-            user_obj.get("email"),
-            institute_obj.get("display_name"),
-        )
-
-        LOG.info("Filter object {}".format(filter_obj))
-
         institute_id = institute_obj.get("_id")
         filter_dict = {"institute_id": institute_id, "category": category}
 
@@ -271,3 +262,29 @@ class FilterHandler(object):
         )
 
         return filters_res
+
+    def set_legacy_options(self, filter_obj):
+        """Update remaining legacy filter options,
+        i.e. filter controls that changed names or functionality.
+        In particular, clinsig_confident_always_returned was split into two different
+        options: clinvar_trusted_revstat and prioritise_clinvar.
+        """
+        if "clinsig_confident_always_returned" not in filter_obj:
+            return
+
+        filter_value = filter_obj.pop("clinsig_confident_always_returned", ["True"])
+        filter_obj["clinvar_trusted_revstat"] = filter_value
+        filter_obj["prioritise_clinvar"] = filter_value
+
+        self.filter_collection.find_one_and_update(
+            {"_id": filter_obj["_id"]},
+            {
+                "$set": {
+                    "clinvar_trusted_revstat": filter_value,
+                    "prioritise_clinvar": filter_value,
+                },
+                "$unset": {
+                    "clinsig_confident_always_returned": "",
+                },
+            },
+        )

scout/adapter/mongo/institute.py

@@ -56,6 +56,7 @@ class InstituteHandler(object):
         check_show_all_vars: Optional[str] = None,
         clinvar_key: Optional[str] = None,
         clinvar_submitters: Optional[List[str]] = None,
+        soft_filters: Optional[dict] = None,
     ) -> Union[dict, str]:
         """Update the information for an institute."""
 
@@ -127,6 +128,7 @@ class InstituteHandler(object):
             "alamut_institution": alamut_institution,
             "clinvar_key": clinvar_key,
             "show_all_cases_status": show_all_cases_status,
+            "soft_filters": soft_filters,
         }
         for key, value in ADMIN_SETTINGS.items():
             if value not in [None, "", []]:

scout/adapter/mongo/omics_variant.py

@@ -1,11 +1,14 @@
 import logging
 from typing import Dict, Optional
 
-from scout.constants import OMICS_FILE_TYPE_MAP
+from pymongo import ASCENDING, DESCENDING
+
+from scout.constants import ORDERED_OMICS_FILE_TYPE_MAP
 from scout.models.omics_variant import OmicsVariantLoader
 from scout.parse.omics_variant import parse_omics_file
 
 LOG = logging.getLogger(__name__)
+SORT_ORDER = {"asc": ASCENDING, "desc": DESCENDING}
 
 
 class OmicsVariantHandler:
@@ -30,7 +33,7 @@ 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)
+        omics_file_type = ORDERED_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"]
@@ -123,7 +126,7 @@ class OmicsVariantHandler:
         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)
+        omics_file_type: dict = ORDERED_OMICS_FILE_TYPE_MAP.get(file_type)
 
         nr_inserted = 0
 
@@ -180,9 +183,21 @@ class OmicsVariantHandler:
         else:
             nr_of_variants = skip + nr_of_variants
 
-        query = self.build_query(case_id, query=query, category=category, build=build)
+        variants_query = self.build_query(case_id, query=query, category=category, build=build)
+
+        if query.get("sort_by") and query.get("sort_order"):
+            return (
+                self.omics_variant_collection.find(variants_query, projection)
+                .sort([(query.get("sort_by"), SORT_ORDER[query.get("sort_order")])])
+                .skip(skip)
+                .limit(nr_of_variants)
+            )
+
         return self.omics_variant_collection.find(
-            query, projection, skip=skip, limit=nr_of_variants
+            variants_query,
+            projection,
+            skip=skip,
+            limit=nr_of_variants,
         )
 
     def count_omics_variants(