scout-browser 4.91.2__py3-none-any.whl → 4.93.1__py3-none-any.whl

scout/__version__.py

@@ -1 +1 @@
-__version__ = "4.91.2"
+__version__ = "4.93.1"

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

@@ -1,7 +1,7 @@
 import logging
 import re
 from datetime import datetime, timedelta
-from typing import Optional, Union
+from typing import List, Optional, Union
 
 from scout.constants import (
     CLINSIG_MAP,
@@ -19,23 +19,19 @@ LOG = logging.getLogger(__name__)
 
 class QueryHandler(object):
     def build_case_query(
-        self, case_id=None, status=None, older_than=None, analysis_type=[]
+        self,
+        case_ids: Optional[List[str]],
+        institute_id: Optional[List[str]],
+        status: Optional[List[str]],
+        older_than: Optional[int],
+        analysis_type: Optional[List[str]],
     ) -> dict:
-        """Build case query based on case id, status and analysis date
-
-        Args:
-            case_id(str): id of a case
-            status(list): one or more case status
-            older_than(int): to select cases older than a number of months
-            case_ids(list): a list of case _ids
-            analysis_type(list): a list of type of analysis ["wgs", "wes", "panel"]
-
-        Returns:
-            case_query(dict): query dictionary
-        """
+        """Build case query based on case id, status and analysis date."""
         case_query = {}
-        if case_id:
-            case_query["_id"] = case_id
+        if case_ids:
+            case_query["_id"] = {"$in": case_ids}
+        if institute_id:
+            case_query["owner"] = institute_id
         if analysis_type:
             case_query["individuals.analysis_type"] = {"$in": analysis_type}
         if older_than:
@@ -43,6 +39,7 @@ class QueryHandler(object):
             case_query["analysis_date"] = {"$lt": older_than_date}
         if status:
             case_query["status"] = {"$in": list(status)}
+
         return case_query
 
     def delete_variants_query(

scout/adapter/mongo/variant.py

@@ -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/delete/delete_command.py

@@ -29,7 +29,14 @@ VARIANT_CATEGORIES = ["mei", "snv", "sv", "cancer", "cancer_sv", "str"]
 
 @click.command("variants", short_help="Delete variants for one or more cases")
 @click.option("-u", "--user", help="User running this command (email)", required=True)
-@click.option("-c", "--case-id", help="Case id")
+@click.option("-c", "--case-id", help="Case id", multiple=True)
+@click.option(
+    "-f",
+    "--case-file",
+    help="Path to file containing list of case IDs",
+    type=click.Path(exists=True),
+)
+@click.option("-i", "--institute", help="Restrict to cases with specified institute ID")
 @click.option(
     "--status",
     type=click.Choice(CASE_STATUSES),
@@ -42,7 +49,6 @@ VARIANT_CATEGORIES = ["mei", "snv", "sv", "cancer", "cancer_sv", "str"]
     "--analysis-type",
     type=click.Choice(["wgs", "wes", "panel"]),
     multiple=True,
-    default=["wgs"],
     help="Type of analysis",
 )
 @click.option("--rank-threshold", type=click.INT, default=5, help="With rank threshold lower than")
@@ -62,7 +68,9 @@ VARIANT_CATEGORIES = ["mei", "snv", "sv", "cancer", "cancer_sv", "str"]
 @with_appcontext
 def variants(
     user: str,
-    case_id: str,
+    case_id: list,
+    case_file: str,
+    institute: str,
     status: list,
     older_than: int,
     analysis_type: list,
@@ -73,6 +81,12 @@ def variants(
 ) -> None:
     """Delete variants for one or more cases"""
 
+    if case_file and case_id:
+        click.echo(
+            "You should specify either case ID (multiple times if needed) or the path to a text file containing a list of case IDs (one per line)."
+        )
+        return
+
     user_obj = store.user(user)
     if user_obj is None:
         click.echo(f"Could not find a user with email '{user}' in database")
@@ -86,7 +100,16 @@ def variants(
     else:
         click.confirm("Variants are going to be deleted from database. Continue?", abort=True)
 
-    case_query = store.build_case_query(case_id, status, older_than, analysis_type)
+    if case_file:
+        case_id = [line.strip() for line in open(case_file).readlines() if line.strip()]
+
+    case_query = store.build_case_query(
+        case_ids=case_id,
+        institute_id=institute,
+        status=status,
+        older_than=older_than,
+        analysis_type=analysis_type,
+    )
     # Estimate the average size of a variant document in database
     avg_var_size = store.collection_stats("variant").get("avgObjSize", 0)  # in bytes
 

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",