scout-browser 4.92__py3-none-any.whl → 4.94__py3-none-any.whl

scout/adapter/mongo/base.py

@@ -34,6 +34,7 @@ from flask import current_app
 from .acmg import ACMGHandler
 from .case import CaseHandler
 from .case_group import CaseGroupHandler
+from .ccv import CCVHandler
 from .clinvar import ClinVarHandler
 from .cytoband import CytobandHandler
 from .disease_terms import DiagnosisHandler
@@ -61,6 +62,7 @@ class MongoAdapter(
     ACMGHandler,
     CaseGroupHandler,
     CaseHandler,
+    CCVHandler,
     ClinVarHandler,
     CytobandHandler,
     DiagnosisHandler,
@@ -97,6 +99,7 @@ class MongoAdapter(
         """Setup connection to database."""
         self.db = database
         self.acmg_collection = database.acmg
+        self.ccv_collection = database.ccv
         self.case_collection = database.case
         self.case_group_collection = database.case_group
         self.clinvar_collection = database.clinvar

scout/adapter/mongo/case.py

@@ -11,7 +11,7 @@ from bson import ObjectId
 from werkzeug.datastructures import ImmutableMultiDict
 
 from scout.build.case import build_case
-from scout.constants import ACMG_MAP, FILE_TYPE_MAP, ID_PROJECTION, OMICS_FILE_TYPE_MAP
+from scout.constants import ACMG_MAP, CCV_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
@@ -1272,6 +1272,16 @@ class CaseHandler(object):
                 {"$set": {"case_id": family_id, "variant_specific": new_specific_id}},
             )
 
+        # update ClinGen-CGC-VIGG classification
+        for ccv_obj in self.ccv_collection.find({"case_id": case_obj["_id"]}):
+            LOG.info("update ClinGen-CGC-VIGG classification: %s", ccv_obj["classification"])
+            ccv_variant = self.variant(ccv_obj["variant_specific"])
+            new_specific_id = get_variantid(ccv_variant, family_id)
+            self.ccv_collection.find_one_and_update(
+                {"_id": ccv_obj["_id"]},
+                {"$set": {"case_id": family_id, "variant_specific": new_specific_id}},
+            )
+
         # update events
         institute_obj = self.institute(case_obj["owner"])
         for event_obj in self.events(institute_obj, case=case_obj):
@@ -1344,6 +1354,7 @@ class CaseHandler(object):
                 'mosaic_tags' : [list of variant ids],
                 'cancer_tier': [list of variant ids],
                 'acmg_classification': [list of variant ids]
+                'ccv_classification': [list of variant ids]
                 'is_commented': [list of variant ids]
         """
         updated_variants = {
@@ -1352,6 +1363,7 @@ class CaseHandler(object):
             "mosaic_tags": [],
             "cancer_tier": [],
             "acmg_classification": [],
+            "ccv_classification": [],
             "is_commented": [],
         }
 
@@ -1394,8 +1406,10 @@ class CaseHandler(object):
                 verb = action
                 if action == "acmg_classification":
                     verb = "acmg"
-                elif action == "is_commented":
+                if action == "is_commented":
                     verb = "comment"
+                if action == "ccv_classification":
+                    verb = "ccv"
 
                 old_event = self.event_collection.find_one(
                     {
@@ -1444,6 +1458,17 @@ class CaseHandler(object):
                         acmg_str=str_classif,
                     )
 
+                if action == "ccv_classification":
+                    str_classif = CCV_MAP.get(old_var.get("ccv_classification"))
+                    updated_variant = self.update_ccv(
+                        institute_obj=institute_obj,
+                        case_obj=case_obj,
+                        user_obj=user_obj,
+                        link=link,
+                        variant_obj=new_var,
+                        ccv_str=str_classif,
+                    )
+
                 if action in update_action_map.keys():
                     updated_variant = update_action_map[action](
                         institute_obj,

scout/adapter/mongo/ccv.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+import logging
+
+import pymongo
+from bson import ObjectId
+
+from scout.build.ccv import build_ccv_evaluation
+from scout.utils.ccv import get_ccv
+
+log = logging.getLogger(__name__)
+
+
+class CCVHandler(object):
+    def submit_ccv_evaluation(
+        self,
+        variant_obj,
+        user_obj,
+        institute_obj,
+        case_obj,
+        link,
+        criteria=None,
+        classification=None,
+    ):
+        """Submit an evaluation to the database
+
+        Get all the relevant information, build an evaluation_obj
+
+        Args:
+            variant_obj(dict)
+            user_obj(dict)
+            institute_obj(dict)
+            case_obj(dict)
+            link(str): variant url
+            criteria(list(dict)):
+                                            [
+                                        {
+                                        'term': str,
+                                        'comment': str,
+                                        'modifier': str,
+                                        'links': list(str)
+                                        },
+                                        .
+                                        .
+                                    ]
+            classification(int)
+        """
+        criteria = criteria or []
+
+        variant_specific = variant_obj["_id"]
+        variant_id = variant_obj["variant_id"]
+        user_id = user_obj["_id"]
+        user_name = user_obj.get("name", user_obj["_id"])
+        institute_id = institute_obj["_id"]
+        case_id = case_obj["_id"]
+
+        evaluation_terms = []
+        for evaluation_info in criteria:
+            term = evaluation_info["term"]
+            if evaluation_info.get("modifier"):
+                term += "_" + evaluation_info.get("modifier")
+            evaluation_terms.append(term)
+
+        if classification is None:
+            classification = get_ccv(evaluation_terms)
+
+        if classification:
+            evaluation_obj = build_ccv_evaluation(
+                variant_specific=variant_specific,
+                variant_id=variant_id,
+                user_id=user_id,
+                user_name=user_name,
+                institute_id=institute_id,
+                case_id=case_id,
+                ccv_classification=classification,
+                ccv_criteria=criteria,
+            )
+
+            self._load_ccv_evaluation(evaluation_obj)
+
+        # Update the ccv classification for the variant:
+        self.update_ccv(institute_obj, case_obj, user_obj, link, variant_obj, classification)
+        return classification
+
+    def _load_ccv_evaluation(self, evaluation_obj):
+        """Load a evaluation object into the database"""
+        res = self.ccv_collection.insert_one(evaluation_obj)
+        return res
+
+    def delete_ccv_evaluation(self, evaluation_obj):
+        """Delete an evaluation from the database
+
+        Args:
+            evaluation_obj(dict)
+
+        """
+        self.ccv_collection.delete_one({"_id": evaluation_obj["_id"]})
+
+    def get_ccv_evaluation(self, evaluation_id):
+        """Get a single evaluation from the database
+
+        Args:
+            evaluation_id(str)
+
+        """
+        return self.ccv_collection.find_one({"_id": ObjectId(evaluation_id)})
+
+    def get_ccv_evaluations(self, variant_obj):
+        """Return all evaluations for a certain variant.
+
+        Args:
+            variant_obj (dict): variant dict from the database
+
+        Returns:
+            pymongo.cursor: database cursor
+        """
+        query = dict(variant_id=variant_obj["variant_id"])
+        res = self.ccv_collection.find(query).sort([("created_at", pymongo.DESCENDING)])
+        return res
+
+    def get_ccv_evaluations_case_specific(self, document_id):
+        """Return all evaluations for a certain variant, in a certain case as determined by document id.
+
+        Args:
+            document_id: variant document id from the db; an md5 hash including the case id.
+
+        Returns:
+            res: pymongo.cursor
+        """
+        query = dict(variant_specific=document_id)
+        res = self.ccv_collection.find(query).sort([("created_at", pymongo.DESCENDING)])
+        return res

scout/adapter/mongo/query.py

@@ -474,63 +474,98 @@ class QueryHandler(object):
 
         return mongo_query
 
-    def sv_coordinate_query(self, query):
-        """Adds genomic coordinated-related filters to the query object
-            This method is called to buid coordinate query for sv variants
-
-        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
+    def get_position_query(self, chrom: str, start: int, end: int) -> dict:
+        """Helper function that returns a dictionary containing start and stop coordinates.
+
+        The position query consists of 3 parts, each of them elements of the $or
+        First part applies to searches when chromosome and end_chrom are the same.
+        Here are the possible overlapping search scenarios:
+        # Case 1
+        # filter                 xxxxxxxxx
+        # Variant           xxxxxxxx
+
+        # Case 2
+        # filter                 xxxxxxxxx
+        # Variant                    xxxxxxxx
+
+        # Case 3
+        # filter                 xxxxxxxxx
+        # Variant                   xx
+
+        # Case 4
+        # filter                 xxxxxxxxx
+        # Variant             xxxxxxxxxxxxxx
+
+        Second and third elements of the $or cover queries for variants where chromosome != end_chrom.
+        In this situation there are the following scenarios:
+        - Case chromosome != end_chrom, position matching 'chromosome'
+        - Case chromosome != end_chrom, position matching 'end_chrom'
+        """
 
-        Returns:
-            coordinate_query(dict): returned object contains coordinate filters for sv variant
+        return {
+            "$or": [
+                # Case chromosome == end_chrom
+                {
+                    "$and": [
+                        {"chromosome": chrom},
+                        {"end_chrom": chrom},
+                        {
+                            "$or": [
+                                # Overlapping cases 1-4 (chromosome == end_chrom)
+                                {"end": {"$gte": start, "$lte": end}},  # Case 1
+                                {"position": {"$gte": start, "$lte": end}},  # Case 2
+                                {
+                                    "$and": [
+                                        {"position": {"$lte": start}},
+                                        {"end": {"$gte": end}},
+                                    ]
+                                },  # Case 3
+                                {
+                                    "$and": [
+                                        {"position": {"$gte": start}},
+                                        {"end": {"$lte": end}},
+                                    ]
+                                },  # Case 4
+                            ]
+                        },
+                    ]
+                },
+                # Case chromosome != end_chrom, position matching 'chromosome'
+                {
+                    "$and": [
+                        {"chromosome": chrom},
+                        {"end_chrom": {"$ne": chrom}},
+                        {"position": {"$gte": start}},
+                        {"position": {"$lte": end}},
+                    ]
+                },
+                # Case chromosome != end_chrom, position matching 'end_chrom'
+                {
+                    "$and": [
+                        {"chromosome": {"$ne": chrom}},
+                        {"end_chrom": chrom},
+                        {"end": {"$gte": start}},
+                        {"end": {"$lte": end}},
+                    ]
+                },
+            ]
+        }
 
+    def sv_coordinate_query(self, query: dict) -> dict:
+        """Adds genomic coordinated-related filters to the query object
+        This method is called to build coordinate query for sv variants
         """
-        coordinate_query = None
-        chromosome_query = {"$or": [{"chromosome": query["chrom"]}, {"end_chrom": query["chrom"]}]}
-        if query.get("start") and query.get("end"):
-            # Query for overlapping intervals. Taking into account these cases:
-            # 1
-            # filter                 xxxxxxxxx
-            # Variant           xxxxxxxx
-
-            # 2
-            # filter                 xxxxxxxxx
-            # Variant                    xxxxxxxx
-
-            # 3
-            # filter                 xxxxxxxxx
-            # Variant                   xx
-
-            # 4
-            # filter                 xxxxxxxxx
-            # Variant             xxxxxxxxxxxxxx
-            position_query = {
-                "$or": [
-                    {"end": {"$gte": int(query["start"]), "$lte": int(query["end"])}},  # 1
-                    {
-                        "position": {
-                            "$lte": int(query["end"]),
-                            "$gte": int(query["start"]),
-                        }
-                    },  # 2
-                    {
-                        "$and": [
-                            {"position": {"$gte": int(query["start"])}},
-                            {"end": {"$lte": int(query["end"])}},
-                        ]
-                    },  # 3
-                    {
-                        "$and": [
-                            {"position": {"$lte": int(query["start"])}},
-                            {"end": {"$gte": int(query["end"])}},
-                        ]
-                    },  # 4
-                ]
+        if (
+            query.get("start") is not None and query.get("end") is not None
+        ):  # query contains full coordinates
+            chrom = query["chrom"]
+            start = int(query["start"])
+            end = int(query["end"])
+            coordinate_query = self.get_position_query(chrom=chrom, start=start, end=end)
+        else:  # query contains only chromosome info
+            coordinate_query = {
+                "$or": [{"chromosome": query["chrom"]}, {"end_chrom": query["chrom"]}]
             }
-            coordinate_query = {"$and": [chromosome_query, position_query]}
-        else:
-            coordinate_query = chromosome_query
         return coordinate_query
 
     def gene_filter(self, query, build="37"):

scout/adapter/mongo/variant.py

@@ -311,14 +311,14 @@ class VariantHandler(VariantLoader):
             "category": variant_obj["category"],  # sv
             "variant_type": variant_obj["variant_type"],  # clinical or research
             "sub_category": variant_obj["sub_category"],  # example -> "del"
-            "$and": coordinate_query["$and"],  # query for overlapping SV variants
+            "$or": coordinate_query["$or"],  # query for overlapping SV variants
         }
-
         overlapping_svs = list(
             self.variant_collection.find(
                 query,
             )
         )
+
         if not overlapping_svs:
             return None
         if len(overlapping_svs) == 1:
@@ -721,7 +721,7 @@ class VariantHandler(VariantLoader):
     def evaluated_variant_ids_from_events(self, case_id, institute_id):
         """Returns variant ids for variants that have been evaluated
            Return all variants, snvs/indels and svs from case case_id
-            which have an event entry for 'acmg_classification', 'manual_rank', 'dismiss_variant',
+            which have an event entry for 'acmg_classification', 'ccv_classification', 'manual_rank', 'dismiss_variant',
             'cancer_tier', 'mosaic_tags'.
         Args:
             case_id(str)
@@ -732,6 +732,7 @@ class VariantHandler(VariantLoader):
 
         evaluation_verbs = [
             "acmg",
+            "ccv",
             "manual_rank",
             "cancer_tier",
             "dismiss_variant",
@@ -758,7 +759,7 @@ class VariantHandler(VariantLoader):
         """Returns variants that have been evaluated
 
         Return all variants, snvs/indels and svs from case case_id and institute_id
-        which have a entry for 'acmg_classification', 'manual_rank', 'dismiss_variant',
+        which have a entry for 'acmg_classification', 'ccv_classification', 'manual_rank', 'dismiss_variant',
         'cancer_tier' or if they are commented.
 
         Return only if the variants still exist and still have the assessment.
@@ -778,11 +779,11 @@ class VariantHandler(VariantLoader):
         query = {
             "$and": [
                 {"variant_id": {"$in": variant_ids}},
-                {"institute": institute_id},
                 {"case_id": case_id},
                 {
                     "$or": [
                         {"acmg_classification": {"$exists": True}},
+                        {"ccv_classification": {"$exists": True}},
                         {"manual_rank": {"$exists": True}},
                         {"cancer_tier": {"$exists": True}},
                         {"dismiss_variant": {"$exists": True}},

scout/adapter/mongo/variant_events.py

@@ -4,7 +4,7 @@ from typing import Dict, List
 
 import pymongo
 
-from scout.constants import CANCER_TIER_OPTIONS, MANUAL_RANK_OPTIONS, REV_ACMG_MAP
+from scout.constants import CANCER_TIER_OPTIONS, MANUAL_RANK_OPTIONS, REV_ACMG_MAP, REV_CCV_MAP
 
 SANGER_OPTIONS = ["True positive", "False positive", "Not validated"]
 
@@ -931,3 +931,47 @@ class VariantEventHandler(object):
 
         LOG.debug("Variant updated")
         return updated_variant
+
+    def update_ccv(self, institute_obj, case_obj, user_obj, link, variant_obj, ccv_str):
+        """Create an event for updating the ClinGen-CGC-VIGG classification of a variant.
+
+        Arguments:
+            institute_obj (dict): A Institute object
+            case_obj (dict): Case object
+            user_obj (dict): A User object
+            link (str): The url to be used in the event
+            variant_obj (dict): A variant object
+            ccv_str (str): The new ClinGen-CGC-VIGG classification string
+
+        Returns:
+            updated_variant
+        """
+        self.create_event(
+            institute=institute_obj,
+            case=case_obj,
+            user=user_obj,
+            link=link,
+            category="variant",
+            verb="ccv",
+            variant=variant_obj,
+            subject=variant_obj["display_name"],
+        )
+        LOG.info(
+            "Setting ClinGen-CGC-VIGG to {} for: {}".format(ccv_str, variant_obj["display_name"])
+        )
+
+        if ccv_str is None:
+            updated_variant = self.variant_collection.find_one_and_update(
+                {"_id": variant_obj["_id"]},
+                {"$unset": {"ccv_classification": 1}},
+                return_document=pymongo.ReturnDocument.AFTER,
+            )
+        else:
+            updated_variant = self.variant_collection.find_one_and_update(
+                {"_id": variant_obj["_id"]},
+                {"$set": {"ccv_classification": REV_CCV_MAP[ccv_str]}},
+                return_document=pymongo.ReturnDocument.AFTER,
+            )
+
+        LOG.debug("Variant updated")
+        return updated_variant

scout/build/ccv.py

@@ -0,0 +1,59 @@
+import logging
+import datetime
+
+LOG = logging.getLogger(__name__)
+
+
+def build_ccv_evaluation(
+    variant_specific,
+    variant_id,
+    user_id,
+    user_name,
+    institute_id,
+    case_id,
+    ccv_classification,
+    ccv_criteria,
+):
+    """Build a ClinGen-CGC-VIGG evaluation object ready to be inserted to database
+
+    Args:
+        variant_specific(str): md5 string for the specific variant
+        variant_id(str): md5 string for the common variant
+        user_id(str)
+        user_name(str)
+        institute_id(str)
+        case_id(str)
+        ccv_classification(str): The ClinGen-CGC-VIGG classification
+        ccv_criteria(list(dict)): A list of dictionaries with ClinGen-CGC-VIGG criteria
+
+    Returns:
+        evaluation_obj(dict): Correctly formatted evaluation object
+
+    """
+    LOG.info(
+        "Creating ClinGen-CGC-VIGG classification: %s for variant %s",
+        ccv_classification,
+        variant_id,
+    )
+    ccv_criteria = ccv_criteria or []
+    evaluation_obj = dict(
+        variant_specific=variant_specific,
+        variant_id=variant_id,
+        institute_id=institute_id,
+        case_id=case_id,
+        ccv_classification=ccv_classification,
+        user_id=user_id,
+        user_name=user_name,
+        created_at=datetime.datetime.now(),
+    )
+    criteria_objs = []
+    for info in ccv_criteria:
+        criteria_obj = {}
+        for criterion_key in ["term", "comment", "links", "modifier"]:
+            if criterion_key in info:
+                criteria_obj[criterion_key] = info[criterion_key]
+        criteria_objs.append(criteria_obj)
+
+    evaluation_obj["ccv_criteria"] = criteria_objs
+
+    return evaluation_obj

scout/commands/serve.py

@@ -22,7 +22,8 @@ def serve(host, port, debug, livereload, test):
     """Start the web server."""
 
     # Verify the database connectivity before launching the app
-    mongo_client = current_app.config.get("MONGO_DATABASE")._Database__client
+    mongo_client = current_app.config.get("MONGO_DATABASE").client
+
     try:
         mongo_client.server_info()
         if test:

scout/constants/__init__.py

@@ -23,6 +23,7 @@ from .case_tags import (
     VERBS_ICONS_MAP,
     VERBS_MAP,
 )
+from .ccv import CCV_COMPLETE_MAP, CCV_CRITERIA, CCV_MAP, CCV_OPTIONS, REV_CCV_MAP
 from .clinvar import (
     AFFECTED_STATUS,
     ALLELE_OF_ORIGIN,
@@ -126,6 +127,7 @@ COLLECTIONS = [
     "disease_term",
     "variant",
     "acmg",
+    "ccv",
 ]
 
 BUILDS = ["37", "38", "GRCh38"]

scout/constants/case_tags.py

@@ -43,6 +43,7 @@ CASE_REPORT_VARIANT_TYPES = {
     "partial_causatives_detailed": "partial_causatives",
     "suspects_detailed": "suspects",
     "classified_detailed": "acmg_classification",
+    "ccv_classified_detailed": "ccv_classification",
     "tagged_detailed": "manual_rank",
     "tier_detailed": "cancer_tier",
     "dismissed_detailed": "dismiss_variant",
@@ -105,6 +106,7 @@ CASE_TAGS = {
 
 VERBS_MAP = {
     "acmg": "updated ACMG classification for",
+    "ccv": "updated ClinGen-CGC-VIGG classification for",
     "add_case": "added case",
     "add_cohort": "updated cohort for",
     "add_phenotype": "added HPO term for",