scout-browser 4.96.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,50 +994,9 @@ 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,
-                    )
-                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_omics_variants(case_obj, build=genome_build, update=update)
+            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.exception(error)
@@ -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"]})
 

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(

scout/adapter/mongo/query.py

@@ -12,7 +12,12 @@ from scout.constants import (
     TRUSTED_REVSTAT_LEVEL,
 )
 
+CLNSIG_NOT_EXISTS = {"clnsig": {"$exists": False}}
+CLNSIG_NULL = {"clnsig": {"$eq": None}}
 CRITERION_EXCLUDE_OPERATOR = {False: "$in", True: "$nin"}
+EXISTS = {"$exists": True}
+NOT_EXISTS = {"$exists": False}
+EXISTS_NOT_NULL = {"$exists": True, "$ne": None}
 
 LOG = logging.getLogger(__name__)
 
@@ -43,18 +48,16 @@ class QueryHandler(object):
         return case_query
 
     def delete_variants_query(
-        self, case_id, variants_to_keep=[], min_rank_threshold=None, keep_ctg=[]
+        self,
+        case_id: str,
+        variants_to_keep: List[str] = [],
+        min_rank_threshold: Optional[int] = None,
+        keep_ctg: List[str] = [],
     ) -> dict:
-        """Build a query to delete variants from a case
-
-        Args:
-            case_id(str): id of a case
-            variants_to_keep(list): a list of variant ids
-            min_rank_threshold(int): remove variants with rank lower than this number
-            keep_ctg(list): exclude one of more variants categories from deletion. Example ["cancer", "cancer_sv"]
+        """Build a query to delete variants from a case (variant collection).
 
-        Return:
-            variant_query(dict): query dictionary
+        Removes variants with rank lower than `min_rank_threshold`.
+        Retains variants in categories `keep_ctg` by excluding them from deletion - eg `["cancer", "cancer_sv"]`.
         """
         variants_query = {}
         case_subquery = {"case_id": case_id}
@@ -202,14 +205,15 @@ class QueryHandler(object):
                 'region_annotations': list,
                 'functional_annotations': list,
                 'clinsig': list,
-                'clinsig_confident_always_returned': boolean,
+                'clinvar_trusted_revstat': boolean,
+                'clinsig_exclude': bool,
                 'variant_type': str(('research', 'clinical')),
                 'chrom': str or list of str,
                 'start': int,
                 'end': int,
                 'svtype': list,
                 'size': int,
-                'size_shorter': boolean,
+                'size_selector': str,
                 'gene_panels': list(str),
                 'mvl_tag": boolean,
                 'clinvar_tag': boolean,
@@ -305,6 +309,9 @@ class QueryHandler(object):
             if criterion == "show_unaffected" and query.get(criterion) is False:
                 self.affected_inds_query(mongo_query, case_id, gt_query)
 
+            if criterion == "show_soft_filtered" and query.get(criterion) is False:
+                self.soft_filters_query(query=query, mongo_query=mongo_query)
+
             ##### end of fundamental query params
 
         ##### start of the custom query params
@@ -319,18 +326,21 @@ class QueryHandler(object):
         for term in PRIMARY_CRITERIA:
             if query.get(term):
                 primary_terms = True
+                break
 
         # check if any of the secondary criteria was specified in the query:
         for term in SECONDARY_CRITERIA:
             if query.get(term):
                 secondary_terms = True
+                break
 
         if primary_terms is True:
-            clinsign_filter = self.clinsig_query(query, mongo_query)
+            clinsign_filter: dict = self.set_and_get_clinsig_query(query, mongo_query)
 
         # Secondary, excluding filter criteria will hide variants in general,
         # but can be overridden by an including, major filter criteria
         # such as a Pathogenic ClinSig.
+
         if secondary_terms is True:
             secondary_filter = self.secondary_query(query, mongo_query)
             # If there are no primary criteria given, all secondary criteria are added as a
@@ -338,26 +348,35 @@ class QueryHandler(object):
             if secondary_filter and primary_terms is False:
                 mongo_query["$and"] = secondary_filter
 
-            # If there is only one primary criterion given without any secondary, it will also be
-            # added as a top level '$and'.
-            # Otherwise, primary criteria are added as a high level '$or' and all secondary criteria
-            # are joined together with them as a single lower level '$and'.
-            if primary_terms is True:  # clinsig is specified
-                # Given a request to always return confident clinical variants,
-                # add the clnsig query as a major criteria, but only
-                # trust clnsig entries with trusted revstat levels.
-                if query.get("clinsig_confident_always_returned") is True:
+            # if prioritise_clinvar checkbox is checked, then clinical_filter will be applied in alternative to the secondary_filter ("$or")
+            # This will happen when the search for ClinVar annotated variants is supposed to be more relaxed compared to other filter constraints, for instance when applying the clinical filter
+            if primary_terms is True:
+                if query.get("prioritise_clinvar") is True:
                     mongo_query["$or"] = [
                         {"$and": secondary_filter},
                         clinsign_filter,
                     ]
-                else:  # clisig terms are provided but no need for trusted revstat levels
+                else:  # clinical_filter will be applied at the same level as the other secondary filters ("$and")
+                    if query.get("clinsig_exclude"):
+                        clinsign_filter = {
+                            "$or": [
+                                clinsign_filter,
+                                CLNSIG_NOT_EXISTS,
+                                CLNSIG_NULL,
+                            ]
+                        }
                     secondary_filter.append(clinsign_filter)
                     mongo_query["$and"] = secondary_filter
 
         elif primary_terms is True:  # clisig is provided without secondary terms query
-            # use implicit and
-            mongo_query["clnsig"] = clinsign_filter["clnsig"]
+            if query.get("clinsig_exclude"):
+                mongo_query["$or"] = [
+                    clinsign_filter,
+                    CLNSIG_NOT_EXISTS,
+                    CLNSIG_NULL,
+                ]
+            else:
+                mongo_query["clnsig"] = clinsign_filter["clnsig"]
 
         # if chromosome coordinates exist in query, add them as first element of the mongo_query['$and']
         if coordinate_query:
@@ -368,6 +387,11 @@ class QueryHandler(object):
 
         return mongo_query
 
+    def soft_filters_query(self, query: dict, mongo_query: dict):
+        """Adds info to variants query to exclude variants flagged by specific filters."""
+        if query.get("institute_soft_filters"):
+            mongo_query["filters"] = {"$nin": query["institute_soft_filters"].split(",")}
+
     def affected_inds_query(self, mongo_query, case_id, gt_query):
         """Add info to variants query to filter out variants which are only in unaffected individuals
 
@@ -393,7 +417,10 @@ class QueryHandler(object):
         for ind in case_inds:
             if ind["phenotype"] in [1, "unaffected"]:  # 1=unaffected, 2=affected
                 continue
-            affected_match = {"sample_id": ind["individual_id"], "genotype_call": gt_query}
+            affected_match = {
+                "sample_id": ind["individual_id"],
+                "genotype_call": gt_query,
+            }
             affected_query["$elemMatch"]["$or"].append(affected_match)
 
         if affected_query["$elemMatch"][
@@ -401,65 +428,52 @@ class QueryHandler(object):
         ]:  # Consider situation where all individuals are unaffected
             mongo_query["samples"] = affected_query
 
-    def clinsig_query(self, query, mongo_query):
-        """Add clinsig filter values to the mongo query object
+    def set_and_get_clinsig_query(self, query: dict, mongo_query: dict) -> dict:
+        """Add clinsig filter values to the mongo query object. if clinvar_tag esists in query then only results with ClinVar annotation are returned."""
 
-        Args:
-            query(dict): a dictionary of query filters specified by the users
-            mongo_query(dict): the query that is going to be submitted to the database
+        clnsig_query = {"clnsig": {}}
 
-        Returns:
-            clinsig_query(dict): a dictionary with clinsig key-values
+        if query.get("clinsig"):  # If any ClinVar significance was selected in the form multiselect
+            rank = []
+            str_rank = []
+            for item in query["clinsig"]:
+                rank.append(int(item))
+                # search for human readable clinsig values in newer cases
+                rank.append(CLINSIG_MAP[int(item)])
+                str_rank.append(CLINSIG_MAP[int(item)])
 
-        """
-        LOG.debug("clinsig is a query parameter")
-        trusted_revision_level = TRUSTED_REVSTAT_LEVEL
-        rank = []
-        str_rank = []
-        clnsig_query = {}
-
-        for item in query["clinsig"]:
-            rank.append(int(item))
-            # search for human readable clinsig values in newer cases
-            rank.append(CLINSIG_MAP[int(item)])
-            str_rank.append(CLINSIG_MAP[int(item)])
-
-        if query.get("clinsig_confident_always_returned") is True:
-            LOG.debug("add CLINSIG filter with trusted_revision_level")
-
-            clnsig_query = {
-                "clnsig": {
+            elem_match = [
+                {"value": {"$in": rank}},
+                {"value": re.compile("|".join(str_rank))},
+            ]
+
+            if query.get("clinsig_exclude"):
+                elem_match_or = {"$nor": elem_match}
+            else:
+                elem_match_or = {"$or": elem_match}
+
+            if query.get("clinvar_trusted_revstat") is True:
+                clnsig_query["clnsig"] = {
                     "$elemMatch": {
                         "$and": [
-                            {
-                                "$or": [
-                                    {"value": {"$in": rank}},
-                                    {"value": re.compile("|".join(str_rank))},
-                                ]
-                            },
-                            {"revstat": re.compile("|".join(trusted_revision_level))},
+                            elem_match_or,
+                            {"revstat": re.compile("|".join(TRUSTED_REVSTAT_LEVEL))},
                         ]
                     }
                 }
-            }
-        else:
-            LOG.debug("add CLINSIG filter for rank: %s" % ", ".join(str(query["clinsig"])))
+            else:
+                clnsig_query["clnsig"] = {"$elemMatch": elem_match_or}
+
+        if query.get("clinvar_tag"):
+            mongo_query["clnsig"] = EXISTS_NOT_NULL  # Used when query has secondary terms
+            clnsig_query["clnsig"]["$exists"] = True
+            clnsig_query["clnsig"]["$ne"] = None
 
-            clnsig_query = {
-                "clnsig": {
-                    "$elemMatch": {
-                        "$or": [
-                            {"value": {"$in": rank}},
-                            {"value": re.compile("|".join(str_rank))},
-                        ]
-                    }
-                }
-            }
         return clnsig_query
 
     def coordinate_filter(self, query, mongo_query):
         """Adds genomic coordinated-related filters to the query object
-            This method is called to buid coordinate query for non-sv variants
+            This method is called to build coordinate query for non-sv variants
 
         Args:
             query(dict): a dictionary of query filters specified by the users
@@ -618,7 +632,7 @@ class QueryHandler(object):
                     {
                         "$or": [
                             {"gnomad_frequency": {"$lt": float(gnomad)}},
-                            {"gnomad_frequency": {"$exists": False}},
+                            {"gnomad_frequency": NOT_EXISTS},
                         ]
                     }
                 )
@@ -656,7 +670,7 @@ class QueryHandler(object):
                     {
                         "$or": [
                             {"swegen_mei_max": {"$lt": float(swegen)}},
-                            {"swegen_mei_max": {"$exists": False}},
+                            {"swegen_mei_max": NOT_EXISTS},
                         ]
                     }
                 )
@@ -665,7 +679,7 @@ class QueryHandler(object):
                 mongo_secondary_query.append(
                     {
                         "$or": [
-                            {criterion: {"$exists": False}},
+                            {criterion: NOT_EXISTS},
                             {criterion: {"$lt": query[criterion] + 1}},
                         ]
                     }
@@ -677,7 +691,7 @@ class QueryHandler(object):
 
                 spidex_query_or_part = []
                 if "not_reported" in spidex_human:
-                    spidex_query_or_part.append({"spidex": {"$exists": False}})
+                    spidex_query_or_part.append({"spidex": NOT_EXISTS})
 
                 for spidex_level in SPIDEX_HUMAN:
                     if spidex_level in spidex_human:
@@ -721,7 +735,7 @@ class QueryHandler(object):
             if criterion == "revel":
                 revel = query["revel"]
                 revel_query = {"revel": {"$gt": float(revel)}}
-                revel_query = {"$or": [revel_query, {"revel": {"$exists": False}}]}
+                revel_query = {"$or": [revel_query, {"revel": NOT_EXISTS}]}
 
                 mongo_secondary_query.append(revel_query)
 
@@ -729,7 +743,7 @@ class QueryHandler(object):
                 rank_score_query = {
                     "$or": [
                         {"rank_score": {"$gte": float(query["rank_score"])}},
-                        {"rank_score": {"$exists": False}},
+                        {"rank_score": NOT_EXISTS},
                     ]
                 }
                 mongo_secondary_query.append(rank_score_query)
@@ -739,7 +753,7 @@ class QueryHandler(object):
                 cadd_query = {"cadd_score": {"$gt": float(cadd)}}
 
                 if query.get("cadd_inclusive") is True:
-                    cadd_query = {"$or": [cadd_query, {"cadd_score": {"$exists": False}}]}
+                    cadd_query = {"$or": [cadd_query, {"cadd_score": NOT_EXISTS}]}
 
                 mongo_secondary_query.append(cadd_query)
 
@@ -763,15 +777,14 @@ class QueryHandler(object):
 
             if criterion == "size":
                 size = query["size"]
-                size_query = {"length": {"$gt": int(size)}}
+                size_selector = query.get("size_selector")
 
-                if query.get("size_shorter"):
-                    size_query = {
-                        "$or": [
-                            {"length": {"$lt": int(size)}},
-                            {"length": {"$exists": False}},
-                        ]
-                    }
+                size_query = {
+                    "$or": [
+                        {"$expr": {size_selector: [{"$abs": "$length"}, size]}},
+                        {"length": NOT_EXISTS},  # Include documents where 'length' is missing
+                    ]
+                }
 
                 mongo_secondary_query.append(size_query)
 
@@ -780,7 +793,7 @@ class QueryHandler(object):
                 mongo_secondary_query.append({"sub_category": {"$in": svtype}})
 
             if criterion == "decipher":
-                mongo_query["decipher"] = {"$exists": True}
+                mongo_query["decipher"] = EXISTS
 
             if criterion == "depth":
                 mongo_secondary_query.append({"tumor.read_depth": {"$gt": query.get("depth")}})
@@ -793,7 +806,7 @@ class QueryHandler(object):
                     {
                         "$or": [
                             {"somatic_score": {"$gt": query.get("somatic_score")}},
-                            {"somatic_score": {"$exists": False}},
+                            {"somatic_score": NOT_EXISTS},
                         ]
                     }
                 )
@@ -809,14 +822,10 @@ class QueryHandler(object):
                 )
 
             if criterion == "mvl_tag":
-                mongo_secondary_query.append({"mvl_tag": {"$exists": True}})
-
-            if criterion == "clinvar_tag":
-                mongo_secondary_query.append({"clnsig": {"$exists": True}})
-                mongo_secondary_query.append({"clnsig": {"$ne": None}})
+                mongo_secondary_query.append({"mvl_tag": EXISTS})
 
             if criterion == "cosmic_tag":
-                mongo_secondary_query.append({"cosmic_ids": {"$exists": True}})
+                mongo_secondary_query.append({"cosmic_ids": EXISTS})
                 mongo_secondary_query.append({"cosmic_ids": {"$ne": None}})
 
             if criterion == "fusion_score":

scout/adapter/mongo/variant.py

@@ -877,11 +877,6 @@ class VariantHandler(VariantLoader):
                     }
                 }
         """
-        LOG.info(
-            "Retrieving variants by category for case: {0}, institute: {1}".format(
-                case_id, institute_id
-            )
-        )
 
         case_obj = self.case(case_id=case_id)
         variants_stats = case_obj.get("variants_stats") or {}